diff --git a/classpath/java-io.cpp b/classpath/java-io.cpp
index 42cab62f79..f9d477520f 100644
--- a/classpath/java-io.cpp
+++ b/classpath/java-io.cpp
@@ -20,40 +20,41 @@
 
 #ifdef PLATFORM_WINDOWS
 
-#  define UNICODE
+#define UNICODE
 
-#  include <windows.h>
-#  include <io.h>
-#  include <direct.h>
-#  include <share.h>
+#include <windows.h>
+#include <io.h>
+#include <direct.h>
+#include <share.h>
 
-#  define ACCESS _waccess
-#  define CLOSE _close
-#  define READ _read
-#  define WRITE _write
-#  define STAT _wstat
-#  define STRUCT_STAT struct _stat
-#  define MKDIR(path, mode) _wmkdir(path)
-#  define CHMOD(path, mode) _wchmod(path, mode)
-#  define REMOVE _wremove
-#  define RENAME _wrename
-#  define OPEN_MASK O_BINARY
+#define ACCESS _waccess
+#define CLOSE _close
+#define READ _read
+#define WRITE _write
+#define STAT _wstat
+#define STRUCT_STAT struct _stat
+#define MKDIR(path, mode) _wmkdir(path)
+#define CHMOD(path, mode) _wchmod(path, mode)
+#define REMOVE _wremove
+#define RENAME _wrename
+#define OPEN_MASK O_BINARY
 
-#  define CHECK_X_OK R_OK
+#define CHECK_X_OK R_OK
 
-#  ifdef _MSC_VER
-#    define S_ISREG(x) ((x) & _S_IFREG)
-#    define S_ISDIR(x) ((x) & _S_IFDIR)
-#    define S_IRUSR _S_IREAD
-#    define S_IWUSR _S_IWRITE
-#    define W_OK 2
-#    define R_OK 4
-#  else
-#    define OPEN _wopen
-#  endif
+#ifdef _MSC_VER
+#define S_ISREG(x) ((x)&_S_IFREG)
+#define S_ISDIR(x) ((x)&_S_IFDIR)
+#define S_IRUSR _S_IREAD
+#define S_IWUSR _S_IWRITE
+#define W_OK 2
+#define R_OK 4
+#else
+#define OPEN _wopen
+#endif
 
-#  define GET_CHARS GetStringChars
-#  define RELEASE_CHARS(path, chars) ReleaseStringChars(path, reinterpret_cast<const jchar*>(chars))
+#define GET_CHARS GetStringChars
+#define RELEASE_CHARS(path, chars) \
+  ReleaseStringChars(path, reinterpret_cast<const jchar*>(chars))
 
 typedef wchar_t char_t;
 
@@ -66,46 +67,49 @@ typedef wchar_t char_t;
 #endif
 #endif
 
-#else // not PLATFORM_WINDOWS
+#else  // not PLATFORM_WINDOWS
 
-#  include <dirent.h>
-#  include <unistd.h>
-#  include "sys/mman.h"
+#include <dirent.h>
+#include <unistd.h>
+#include "sys/mman.h"
 
-#  define ACCESS access
-#  define OPEN open
-#  define CLOSE close
-#  define READ read
-#  define WRITE write
-#  define STAT stat
-#  define STRUCT_STAT struct stat
-#  define MKDIR mkdir
-#  define CHMOD chmod
-#  define REMOVE remove
-#  define RENAME rename
-#  define OPEN_MASK 0
+#define ACCESS access
+#define OPEN open
+#define CLOSE close
+#define READ read
+#define WRITE write
+#define STAT stat
+#define STRUCT_STAT struct stat
+#define MKDIR mkdir
+#define CHMOD chmod
+#define REMOVE remove
+#define RENAME rename
+#define OPEN_MASK 0
 
-#  define CHECK_X_OK X_OK
+#define CHECK_X_OK X_OK
 
-#  define GET_CHARS GetStringUTFChars
-#  define RELEASE_CHARS ReleaseStringUTFChars
+#define GET_CHARS GetStringUTFChars
+#define RELEASE_CHARS ReleaseStringUTFChars
 
 typedef char char_t;
 
-#endif // not PLATFORM_WINDOWS
+#endif  // not PLATFORM_WINDOWS
 
 #ifndef WINAPI_FAMILY
-#  ifndef WINAPI_PARTITION_DESKTOP
-#    define WINAPI_PARTITION_DESKTOP 1
-#  endif
+#ifndef WINAPI_PARTITION_DESKTOP
+#define WINAPI_PARTITION_DESKTOP 1
+#endif
 
-#  ifndef WINAPI_FAMILY_PARTITION
-#    define WINAPI_FAMILY_PARTITION(x) (x)
-#  endif
-#endif // WINAPI_FAMILY
+#ifndef WINAPI_FAMILY_PARTITION
+#define WINAPI_FAMILY_PARTITION(x) (x)
+#endif
+#endif  // WINAPI_FAMILY
 
 #if !defined(SKIP_OPERATOR_NEW)
-inline void* operator new(size_t, void* p) throw() { return p; }
+inline void* operator new(size_t, void* p) throw()
+{
+  return p;
+}
 #endif
 
 typedef const char_t* string_t;
@@ -113,20 +117,18 @@ typedef const char_t* string_t;
 namespace {
 
 #ifdef _MSC_VER
-inline int 
-OPEN(string_t path, int mask, int mode)
+inline int OPEN(string_t path, int mask, int mode)
 {
-  int fd; 
+  int fd;
   if (_wsopen_s(&fd, path, mask, _SH_DENYNO, mode) == 0) {
-    return fd; 
+    return fd;
   } else {
-    return -1; 
+    return -1;
   }
 }
 #endif
 
-inline bool
-exists(string_t path)
+inline bool exists(string_t path)
 {
 #ifdef PLATFORM_WINDOWS
   return GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES;
@@ -136,8 +138,7 @@ exists(string_t path)
 #endif
 }
 
-inline int
-doOpen(JNIEnv* e, string_t path, int mask)
+inline int doOpen(JNIEnv* e, string_t path, int mask)
 {
   int fd = OPEN(path, mask | OPEN_MASK, S_IRUSR | S_IWUSR);
   if (fd == -1) {
@@ -150,8 +151,7 @@ doOpen(JNIEnv* e, string_t path, int mask)
   return fd;
 }
 
-inline void
-doClose(JNIEnv* e, jint fd)
+inline void doClose(JNIEnv* e, jint fd)
 {
   int r = CLOSE(fd);
   if (r == -1) {
@@ -159,8 +159,7 @@ doClose(JNIEnv* e, jint fd)
   }
 }
 
-inline int
-doRead(JNIEnv* e, jint fd, jbyte* data, jint length)
+inline int doRead(JNIEnv* e, jint fd, jbyte* data, jint length)
 {
   int r = READ(fd, data, length);
   if (r > 0) {
@@ -170,11 +169,10 @@ doRead(JNIEnv* e, jint fd, jbyte* data, jint length)
   } else {
     throwNewErrno(e, "java/io/IOException");
     return 0;
-  }  
+  }
 }
 
-inline void
-doWrite(JNIEnv* e, jint fd, const jbyte* data, jint length)
+inline void doWrite(JNIEnv* e, jint fd, const jbyte* data, jint length)
 {
   int r = WRITE(fd, data, length);
   if (r != length) {
@@ -182,14 +180,16 @@ doWrite(JNIEnv* e, jint fd, const jbyte* data, jint length)
   }
 }
 
-
 #ifdef PLATFORM_WINDOWS
 
 class Directory {
  public:
-  Directory(): handle(0), findNext(false) { }
+  Directory() : handle(0), findNext(false)
+  {
+  }
 
-  virtual string_t next() {
+  virtual string_t next()
+  {
     if (handle and handle != INVALID_HANDLE_VALUE) {
       if (findNext) {
         if (FindNextFileW(handle, &data)) {
@@ -203,7 +203,8 @@ class Directory {
     return 0;
   }
 
-  virtual void dispose() {
+  virtual void dispose()
+  {
     if (handle and handle != INVALID_HANDLE_VALUE) {
       FindClose(handle);
     }
@@ -215,33 +216,34 @@ class Directory {
   bool findNext;
 };
 
-#else // not PLATFORM_WINDOWS
+#else  // not PLATFORM_WINDOWS
 
-#endif // not PLATFORM_WINDOWS
+#endif  // not PLATFORM_WINDOWS
 
+}  // namespace
 
-} // namespace
-
-static inline string_t getChars(JNIEnv* e, jstring path) {
+static inline string_t getChars(JNIEnv* e, jstring path)
+{
   return reinterpret_cast<string_t>(e->GET_CHARS(path, 0));
 }
 
-static inline void releaseChars(JNIEnv* e, jstring path, string_t chars) {
+static inline void releaseChars(JNIEnv* e, jstring path, string_t chars)
+{
   e->RELEASE_CHARS(path, chars);
 }
 
 extern "C" JNIEXPORT jstring JNICALL
-Java_java_io_File_toCanonicalPath(JNIEnv* /*e*/, jclass, jstring path)
+    Java_java_io_File_toCanonicalPath(JNIEnv* /*e*/, jclass, jstring path)
 {
   // todo
   return path;
 }
 
 extern "C" JNIEXPORT jstring JNICALL
-Java_java_io_File_toAbsolutePath(JNIEnv* e UNUSED, jclass, jstring path)
+    Java_java_io_File_toAbsolutePath(JNIEnv* e UNUSED, jclass, jstring path)
 {
 #ifdef PLATFORM_WINDOWS
-# if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
   string_t chars = getChars(e, path);
   if (chars) {
     const unsigned BufferSize = MAX_PATH;
@@ -250,25 +252,25 @@ Java_java_io_File_toAbsolutePath(JNIEnv* e UNUSED, jclass, jstring path)
     releaseChars(e, path, chars);
 
     if (success) {
-      return e->NewString
-        (reinterpret_cast<const jchar*>(buffer), wcslen(buffer));
+      return e->NewString(reinterpret_cast<const jchar*>(buffer),
+                          wcslen(buffer));
     }
   }
 
   return path;
-# else
+#else
   string_t chars = getChars(e, path);
-  if(chars) {
+  if (chars) {
     std::wstring partialPath = chars;
     releaseChars(e, path, chars);
 
     std::wstring fullPath = AvianInterop::GetFullPath(partialPath);
 
-    return e->NewString
-      (reinterpret_cast<const jchar*>(fullPath.c_str()), fullPath.length());
+    return e->NewString(reinterpret_cast<const jchar*>(fullPath.c_str()),
+                        fullPath.length());
   }
   return path;
-# endif
+#endif
 #else
   jstring result = path;
   string_t chars = getChars(e, path);
@@ -290,62 +292,61 @@ Java_java_io_File_toAbsolutePath(JNIEnv* e UNUSED, jclass, jstring path)
 }
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_java_io_File_length(JNIEnv* e, jclass, jstring path)
+    Java_java_io_File_length(JNIEnv* e, jclass, jstring path)
 {
-  #ifdef PLATFORM_WINDOWS
-    // Option: without opening file
-    // http://msdn.microsoft.com/en-us/library/windows/desktop/aa364946(v=vs.85).aspx
-    string_t chars = getChars(e, path);
-    if(chars) {
-      LARGE_INTEGER fileSize;
-      #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-      HANDLE file = CreateFileW
-        (chars, FILE_READ_DATA, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
-      #else
-      HANDLE file = CreateFile2
-        (chars, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr);
-      #endif
-      releaseChars(e, path, chars);
-      if (file == INVALID_HANDLE_VALUE)
-        return 0;
-      #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-      if(!GetFileSizeEx(file, &fileSize))
-      {
-        CloseHandle(file);
-        return 0;
-      }
-      #else
-      FILE_STANDARD_INFO info;
-      if(!GetFileInformationByHandleEx(file,  FileStandardInfo, &info, sizeof(info)))
-      {
-        CloseHandle(file);
-        return 0;
-      }
-      fileSize = info.EndOfFile;
-      #endif
-
+#ifdef PLATFORM_WINDOWS
+  // Option: without opening file
+  // http://msdn.microsoft.com/en-us/library/windows/desktop/aa364946(v=vs.85).aspx
+  string_t chars = getChars(e, path);
+  if (chars) {
+    LARGE_INTEGER fileSize;
+#if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+    HANDLE file = CreateFileW(
+        chars, FILE_READ_DATA, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
+#else
+    HANDLE file = CreateFile2(
+        chars, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr);
+#endif
+    releaseChars(e, path, chars);
+    if (file == INVALID_HANDLE_VALUE)
+      return 0;
+#if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+    if (!GetFileSizeEx(file, &fileSize)) {
       CloseHandle(file);
-      return static_cast<jlong>(fileSize.QuadPart);
+      return 0;
     }
-  #else
-
-    string_t chars = getChars(e, path);
-    if (chars) {
-      STRUCT_STAT s;
-      int r = STAT(chars, &s);
-      releaseChars(e, path, chars);
-      if (r == 0) {
-        return s.st_size;
-      }
+#else
+    FILE_STANDARD_INFO info;
+    if (!GetFileInformationByHandleEx(
+            file, FileStandardInfo, &info, sizeof(info))) {
+      CloseHandle(file);
+      return 0;
     }
+    fileSize = info.EndOfFile;
+#endif
 
-  #endif
+    CloseHandle(file);
+    return static_cast<jlong>(fileSize.QuadPart);
+  }
+#else
+
+  string_t chars = getChars(e, path);
+  if (chars) {
+    STRUCT_STAT s;
+    int r = STAT(chars, &s);
+    releaseChars(e, path, chars);
+    if (r == 0) {
+      return s.st_size;
+    }
+  }
+
+#endif
 
   return 0;
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_io_File_mkdir(JNIEnv* e, jclass, jstring path)
+    Java_java_io_File_mkdir(JNIEnv* e, jclass, jstring path)
 {
   string_t chars = getChars(e, path);
   if (chars) {
@@ -360,7 +361,7 @@ Java_java_io_File_mkdir(JNIEnv* e, jclass, jstring path)
 }
 
 extern "C" JNIEXPORT jboolean JNICALL
-Java_java_io_File_createNewFile(JNIEnv* e, jclass, jstring path)
+    Java_java_io_File_createNewFile(JNIEnv* e, jclass, jstring path)
 {
   bool result = false;
   string_t chars = getChars(e, path);
@@ -382,7 +383,7 @@ Java_java_io_File_createNewFile(JNIEnv* e, jclass, jstring path)
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_io_File_delete(JNIEnv* e, jclass, jstring path)
+    Java_java_io_File_delete(JNIEnv* e, jclass, jstring path)
 {
   string_t chars = getChars(e, path);
   if (chars) {
@@ -395,7 +396,7 @@ Java_java_io_File_delete(JNIEnv* e, jclass, jstring path)
 }
 
 extern "C" JNIEXPORT jboolean JNICALL
-Java_java_io_File_canRead(JNIEnv* e, jclass, jstring path)
+    Java_java_io_File_canRead(JNIEnv* e, jclass, jstring path)
 {
   string_t chars = getChars(e, path);
   if (chars) {
@@ -407,7 +408,7 @@ Java_java_io_File_canRead(JNIEnv* e, jclass, jstring path)
 }
 
 extern "C" JNIEXPORT jboolean JNICALL
-Java_java_io_File_canWrite(JNIEnv* e, jclass, jstring path)
+    Java_java_io_File_canWrite(JNIEnv* e, jclass, jstring path)
 {
   string_t chars = getChars(e, path);
   if (chars) {
@@ -419,7 +420,7 @@ Java_java_io_File_canWrite(JNIEnv* e, jclass, jstring path)
 }
 
 extern "C" JNIEXPORT jboolean JNICALL
-Java_java_io_File_canExecute(JNIEnv* e, jclass, jstring path)
+    Java_java_io_File_canExecute(JNIEnv* e, jclass, jstring path)
 {
   string_t chars = getChars(e, path);
   if (chars) {
@@ -432,13 +433,17 @@ Java_java_io_File_canExecute(JNIEnv* e, jclass, jstring path)
 
 #ifndef PLATFORM_WINDOWS
 extern "C" JNIEXPORT jboolean JNICALL
-Java_java_io_File_setExecutable(JNIEnv* e, jclass, jstring path, jboolean executable, jboolean ownerOnly)
+    Java_java_io_File_setExecutable(JNIEnv* e,
+                                    jclass,
+                                    jstring path,
+                                    jboolean executable,
+                                    jboolean ownerOnly)
 {
   string_t chars = getChars(e, path);
-  if(chars) {
+  if (chars) {
     jboolean v;
     int mask;
-    if(ownerOnly) {
+    if (ownerOnly) {
       mask = S_IXUSR;
     } else {
       mask = S_IXUSR | S_IXGRP | S_IXOTH;
@@ -446,14 +451,14 @@ Java_java_io_File_setExecutable(JNIEnv* e, jclass, jstring path, jboolean execut
 
     STRUCT_STAT s;
     int r = STAT(chars, &s);
-    if(r == 0) {
+    if (r == 0) {
       int mode = s.st_mode;
-      if(executable) {
+      if (executable) {
         mode |= mask;
       } else {
         mode &= ~mask;
       }
-      if(CHMOD(chars, mode) != 0) {
+      if (CHMOD(chars, mode) != 0) {
         v = false;
       } else {
         v = true;
@@ -467,10 +472,14 @@ Java_java_io_File_setExecutable(JNIEnv* e, jclass, jstring path, jboolean execut
   return false;
 }
 
-#else // ifndef PLATFORM_WINDOWS
+#else  // ifndef PLATFORM_WINDOWS
 
 extern "C" JNIEXPORT jboolean JNICALL
-Java_java_io_File_setExecutable(JNIEnv*, jclass, jstring, jboolean executable, jboolean)
+    Java_java_io_File_setExecutable(JNIEnv*,
+                                    jclass,
+                                    jstring,
+                                    jboolean executable,
+                                    jboolean)
 {
   return executable;
 }
@@ -478,7 +487,7 @@ Java_java_io_File_setExecutable(JNIEnv*, jclass, jstring, jboolean executable, j
 #endif
 
 extern "C" JNIEXPORT jboolean JNICALL
-Java_java_io_File_rename(JNIEnv* e, jclass, jstring old, jstring new_)
+    Java_java_io_File_rename(JNIEnv* e, jclass, jstring old, jstring new_)
 {
   string_t oldChars = getChars(e, old);
   string_t newChars = getChars(e, new_);
@@ -499,7 +508,7 @@ Java_java_io_File_rename(JNIEnv* e, jclass, jstring old, jstring new_)
 }
 
 extern "C" JNIEXPORT jboolean JNICALL
-Java_java_io_File_isDirectory(JNIEnv* e, jclass, jstring path)
+    Java_java_io_File_isDirectory(JNIEnv* e, jclass, jstring path)
 {
   string_t chars = getChars(e, path);
   if (chars) {
@@ -514,7 +523,7 @@ Java_java_io_File_isDirectory(JNIEnv* e, jclass, jstring path)
 }
 
 extern "C" JNIEXPORT jboolean JNICALL
-Java_java_io_File_isFile(JNIEnv* e, jclass, jstring path)
+    Java_java_io_File_isFile(JNIEnv* e, jclass, jstring path)
 {
   string_t chars = getChars(e, path);
   if (chars) {
@@ -529,7 +538,7 @@ Java_java_io_File_isFile(JNIEnv* e, jclass, jstring path)
 }
 
 extern "C" JNIEXPORT jboolean JNICALL
-Java_java_io_File_exists(JNIEnv* e, jclass, jstring path)
+    Java_java_io_File_exists(JNIEnv* e, jclass, jstring path)
 {
   string_t chars = getChars(e, path);
   if (chars) {
@@ -542,61 +551,60 @@ Java_java_io_File_exists(JNIEnv* e, jclass, jstring path)
 }
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_java_io_File_lastModified(JNIEnv* e, jclass, jstring path)
+    Java_java_io_File_lastModified(JNIEnv* e, jclass, jstring path)
 {
   string_t chars = getChars(e, path);
   if (chars) {
 #ifdef PLATFORM_WINDOWS
-      // Option: without opening file
-      // http://msdn.microsoft.com/en-us/library/windows/desktop/aa364946(v=vs.85).aspx
-#  if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-      HANDLE hFile = CreateFileW
-        (chars, FILE_READ_DATA, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
-#  else
-      HANDLE hFile = CreateFile2
-        (chars, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr);
-#  endif
-      releaseChars(e, path, chars);
-      if (hFile == INVALID_HANDLE_VALUE)
-        return 0;
-      LARGE_INTEGER fileDate, filetimeToUnixEpochAdjustment;
-      filetimeToUnixEpochAdjustment.QuadPart = 11644473600000L * 10000L;
-#  if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-      FILETIME fileLastWriteTime;
-      if (!GetFileTime(hFile, 0, 0, &fileLastWriteTime))
-      {
-        CloseHandle(hFile);
-        return 0;
-      }
-      fileDate.HighPart = fileLastWriteTime.dwHighDateTime;
-      fileDate.LowPart = fileLastWriteTime.dwLowDateTime;
-#  else
-      FILE_BASIC_INFO fileInfo;
-      if (!GetFileInformationByHandleEx(hFile,  FileBasicInfo, &fileInfo, sizeof(fileInfo)))
-      {
-        CloseHandle(hFile);
-        return 0;
-      }
-      fileDate = fileInfo.ChangeTime;
-#  endif
-      CloseHandle(hFile);
-      fileDate.QuadPart -= filetimeToUnixEpochAdjustment.QuadPart;
-      return fileDate.QuadPart / 10000000L;
+// Option: without opening file
+// http://msdn.microsoft.com/en-us/library/windows/desktop/aa364946(v=vs.85).aspx
+#if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+    HANDLE hFile = CreateFileW(
+        chars, FILE_READ_DATA, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
 #else
-      struct stat fileStat;
-      int res = stat(chars, &fileStat);
-      releaseChars(e, path, chars);
+    HANDLE hFile = CreateFile2(
+        chars, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr);
+#endif
+    releaseChars(e, path, chars);
+    if (hFile == INVALID_HANDLE_VALUE)
+      return 0;
+    LARGE_INTEGER fileDate, filetimeToUnixEpochAdjustment;
+    filetimeToUnixEpochAdjustment.QuadPart = 11644473600000L * 10000L;
+#if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+    FILETIME fileLastWriteTime;
+    if (!GetFileTime(hFile, 0, 0, &fileLastWriteTime)) {
+      CloseHandle(hFile);
+      return 0;
+    }
+    fileDate.HighPart = fileLastWriteTime.dwHighDateTime;
+    fileDate.LowPart = fileLastWriteTime.dwLowDateTime;
+#else
+    FILE_BASIC_INFO fileInfo;
+    if (!GetFileInformationByHandleEx(
+            hFile, FileBasicInfo, &fileInfo, sizeof(fileInfo))) {
+      CloseHandle(hFile);
+      return 0;
+    }
+    fileDate = fileInfo.ChangeTime;
+#endif
+    CloseHandle(hFile);
+    fileDate.QuadPart -= filetimeToUnixEpochAdjustment.QuadPart;
+    return fileDate.QuadPart / 10000000L;
+#else
+    struct stat fileStat;
+    int res = stat(chars, &fileStat);
+    releaseChars(e, path, chars);
 
-      if (res == -1) {
-        return 0;
-      }
-#  ifdef __APPLE__
-      #define MTIME st_mtimespec
-#  else
-      #define MTIME st_mtim
-#  endif
-      return (static_cast<jlong>(fileStat.MTIME.tv_sec) * 1000) +
-        (static_cast<jlong>(fileStat.MTIME.tv_nsec) / (1000*1000));
+    if (res == -1) {
+      return 0;
+    }
+#ifdef __APPLE__
+#define MTIME st_mtimespec
+#else
+#define MTIME st_mtim
+#endif
+    return (static_cast<jlong>(fileStat.MTIME.tv_sec) * 1000)
+           + (static_cast<jlong>(fileStat.MTIME.tv_nsec) / (1000 * 1000));
 #endif
   }
 
@@ -606,7 +614,7 @@ Java_java_io_File_lastModified(JNIEnv* e, jclass, jstring path)
 #ifdef PLATFORM_WINDOWS
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_java_io_File_openDir(JNIEnv* e, jclass, jstring path)
+    Java_java_io_File_openDir(JNIEnv* e, jclass, jstring path)
 {
   string_t chars = getChars(e, path);
   if (chars) {
@@ -620,11 +628,16 @@ Java_java_io_File_openDir(JNIEnv* e, jclass, jstring path)
     releaseChars(e, path, chars);
 
     Directory* d = new (malloc(sizeof(Directory))) Directory;
-    #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
     d->handle = FindFirstFileW(RUNTIME_ARRAY_BODY(buffer), &(d->data));
-    #else
-    d->handle = FindFirstFileExW(RUNTIME_ARRAY_BODY(buffer), FindExInfoStandard, &(d->data), FindExSearchNameMatch, NULL, 0);
-    #endif
+#else
+    d->handle = FindFirstFileExW(RUNTIME_ARRAY_BODY(buffer),
+                                 FindExInfoStandard,
+                                 &(d->data),
+                                 FindExSearchNameMatch,
+                                 NULL,
+                                 0);
+#endif
     if (d->handle == INVALID_HANDLE_VALUE) {
       d->dispose();
       d = 0;
@@ -637,7 +650,7 @@ Java_java_io_File_openDir(JNIEnv* e, jclass, jstring path)
 }
 
 extern "C" JNIEXPORT jstring JNICALL
-Java_java_io_File_readDir(JNIEnv* e, jclass, jlong handle)
+    Java_java_io_File_readDir(JNIEnv* e, jclass, jlong handle)
 {
   Directory* d = reinterpret_cast<Directory*>(handle);
 
@@ -656,15 +669,15 @@ Java_java_io_File_readDir(JNIEnv* e, jclass, jlong handle)
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_io_File_closeDir(JNIEnv* , jclass, jlong handle)
+    Java_java_io_File_closeDir(JNIEnv*, jclass, jlong handle)
 {
   reinterpret_cast<Directory*>(handle)->dispose();
 }
 
-#else // not PLATFORM_WINDOWS
+#else  // not PLATFORM_WINDOWS
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_java_io_File_openDir(JNIEnv* e, jclass, jstring path)
+    Java_java_io_File_openDir(JNIEnv* e, jclass, jstring path)
 {
   string_t chars = getChars(e, path);
   if (chars) {
@@ -677,18 +690,17 @@ Java_java_io_File_openDir(JNIEnv* e, jclass, jstring path)
 }
 
 extern "C" JNIEXPORT jstring JNICALL
-Java_java_io_File_readDir(JNIEnv* e, jclass, jlong handle)
+    Java_java_io_File_readDir(JNIEnv* e, jclass, jlong handle)
 {
-  struct dirent * directoryEntry;
+  struct dirent* directoryEntry;
 
-  if (handle!=0) {
+  if (handle != 0) {
     while (true) {
       directoryEntry = readdir(reinterpret_cast<DIR*>(handle));
       if (directoryEntry == NULL) {
         return NULL;
       } else if (strcmp(directoryEntry->d_name, ".") == 0
-                 || strcmp(directoryEntry->d_name, "..") == 0)
-      {
+                 || strcmp(directoryEntry->d_name, "..") == 0) {
         // skip . or .. and try again
       } else {
         return e->NewStringUTF(directoryEntry->d_name);
@@ -699,30 +711,30 @@ Java_java_io_File_readDir(JNIEnv* e, jclass, jlong handle)
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_io_File_closeDir(JNIEnv* , jclass, jlong handle)
+    Java_java_io_File_closeDir(JNIEnv*, jclass, jlong handle)
 {
-  if (handle!=0) {
+  if (handle != 0) {
     closedir(reinterpret_cast<DIR*>(handle));
   }
 }
 
-#endif // not PLATFORM_WINDOWS
+#endif  // not PLATFORM_WINDOWS
 
 extern "C" JNIEXPORT jint JNICALL
-Java_java_io_FileInputStream_open(JNIEnv* e, jclass, jstring path)
+    Java_java_io_FileInputStream_open(JNIEnv* e, jclass, jstring path)
 {
-  string_t chars = getChars(e, path); 
+  string_t chars = getChars(e, path);
   if (chars) {
     int fd = doOpen(e, chars, O_RDONLY);
     releaseChars(e, path, chars);
-    return fd; 
+    return fd;
   } else {
-    return -1; 
+    return -1;
   }
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_java_io_FileInputStream_read__I(JNIEnv* e, jclass, jint fd)
+    Java_java_io_FileInputStream_read__I(JNIEnv* e, jclass, jint fd)
 {
   jbyte data;
   int r = doRead(e, fd, &data, 1);
@@ -734,13 +746,17 @@ Java_java_io_FileInputStream_read__I(JNIEnv* e, jclass, jint fd)
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_java_io_FileInputStream_read__I_3BII
-(JNIEnv* e, jclass, jint fd, jbyteArray b, jint offset, jint length)
+    Java_java_io_FileInputStream_read__I_3BII(JNIEnv* e,
+                                              jclass,
+                                              jint fd,
+                                              jbyteArray b,
+                                              jint offset,
+                                              jint length)
 {
   jbyte* data = static_cast<jbyte*>(malloc(length));
   if (data == 0) {
     throwNew(e, "java/lang/OutOfMemoryError", 0);
-    return 0;    
+    return 0;
   }
 
   int r = doRead(e, fd, data, length);
@@ -753,19 +769,23 @@ Java_java_io_FileInputStream_read__I_3BII
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_io_FileInputStream_close(JNIEnv* e, jclass, jint fd)
+    Java_java_io_FileInputStream_close(JNIEnv* e, jclass, jint fd)
 {
   doClose(e, fd);
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_java_io_FileOutputStream_open(JNIEnv* e, jclass, jstring path, jboolean append)
+    Java_java_io_FileOutputStream_open(JNIEnv* e,
+                                       jclass,
+                                       jstring path,
+                                       jboolean append)
 {
   string_t chars = getChars(e, path);
   if (chars) {
-    int fd = doOpen(e, chars, append
-                    ? (O_WRONLY | O_CREAT | O_APPEND)
-                    : (O_WRONLY | O_CREAT | O_TRUNC));
+    int fd = doOpen(e,
+                    chars,
+                    append ? (O_WRONLY | O_CREAT | O_APPEND)
+                           : (O_WRONLY | O_CREAT | O_TRUNC));
     releaseChars(e, path, chars);
     return fd;
   } else {
@@ -774,21 +794,25 @@ Java_java_io_FileOutputStream_open(JNIEnv* e, jclass, jstring path, jboolean app
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_io_FileOutputStream_write__II(JNIEnv* e, jclass, jint fd, jint c)
+    Java_java_io_FileOutputStream_write__II(JNIEnv* e, jclass, jint fd, jint c)
 {
   jbyte data = c;
   doWrite(e, fd, &data, 1);
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_io_FileOutputStream_write__I_3BII
-(JNIEnv* e, jclass, jint fd, jbyteArray b, jint offset, jint length)
+    Java_java_io_FileOutputStream_write__I_3BII(JNIEnv* e,
+                                                jclass,
+                                                jint fd,
+                                                jbyteArray b,
+                                                jint offset,
+                                                jint length)
 {
   jbyte* data = static_cast<jbyte*>(malloc(length));
 
   if (data == 0) {
     throwNew(e, "java/lang/OutOfMemoryError", 0);
-    return;    
+    return;
   }
 
   e->GetByteArrayRegion(b, offset, length, data);
@@ -800,49 +824,53 @@ Java_java_io_FileOutputStream_write__I_3BII
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_io_FileOutputStream_close(JNIEnv* e, jclass, jint fd)
+    Java_java_io_FileOutputStream_close(JNIEnv* e, jclass, jint fd)
 {
   doClose(e, fd);
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_io_RandomAccessFile_open(JNIEnv* e, jclass, jstring path,
-                                   jboolean allowWrite, jlongArray result)
+    Java_java_io_RandomAccessFile_open(JNIEnv* e,
+                                       jclass,
+                                       jstring path,
+                                       jboolean allowWrite,
+                                       jlongArray result)
 {
   string_t chars = getChars(e, path);
   if (chars) {
     jlong peer = 0;
     jlong length = 0;
     int flags = (allowWrite ? O_RDWR | O_CREAT : O_RDONLY) | OPEN_MASK;
-    #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-    #if defined(PLATFORM_WINDOWS)
+#if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#if defined(PLATFORM_WINDOWS)
     int fd = ::_wopen(chars, flags);
-    #else
+#else
     int fd = ::open((const char*)chars, flags, 0666);
-    #endif
+#endif
     releaseChars(e, path, chars);
     if (fd == -1) {
       throwNewErrno(e, "java/io/IOException");
       return;
     }
     struct ::stat fileStats;
-    if(::fstat(fd, &fileStats) == -1) {
+    if (::fstat(fd, &fileStats) == -1) {
       ::close(fd);
       throwNewErrno(e, "java/io/IOException");
       return;
     }
     peer = fd;
     length = fileStats.st_size;
-    #else
-    HANDLE hFile = CreateFile2
-      (chars, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr);
+#else
+    HANDLE hFile = CreateFile2(
+        chars, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr);
     if (hFile == INVALID_HANDLE_VALUE) {
       throwNewErrno(e, "java/io/IOException");
       return;
     }
 
     FILE_STANDARD_INFO info;
-    if(!GetFileInformationByHandleEx(hFile,  FileStandardInfo, &info, sizeof(info))) {
+    if (!GetFileInformationByHandleEx(
+            hFile, FileStandardInfo, &info, sizeof(info))) {
       CloseHandle(hFile);
       throwNewErrno(e, "java/io/IOException");
       return;
@@ -850,7 +878,7 @@ Java_java_io_RandomAccessFile_open(JNIEnv* e, jclass, jstring path,
 
     peer = (jlong)hFile;
     length = info.EndOfFile.QuadPart;
-    #endif
+#endif
 
     e->SetLongArrayRegion(result, 0, 1, &peer);
     e->SetLongArrayRegion(result, 1, 1, &length);
@@ -858,24 +886,28 @@ Java_java_io_RandomAccessFile_open(JNIEnv* e, jclass, jstring path,
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_java_io_RandomAccessFile_readBytes(JNIEnv* e, jclass, jlong peer,
-                                   jlong position, jbyteArray buffer,
-                                   int offset, int length)
+    Java_java_io_RandomAccessFile_readBytes(JNIEnv* e,
+                                            jclass,
+                                            jlong peer,
+                                            jlong position,
+                                            jbyteArray buffer,
+                                            int offset,
+                                            int length)
 {
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
   int fd = (int)peer;
-  if(::lseek(fd, position, SEEK_SET) == -1) {
+  if (::lseek(fd, position, SEEK_SET) == -1) {
     throwNewErrno(e, "java/io/IOException");
     return -1;
   }
-  
-  uint8_t* dst = reinterpret_cast<uint8_t*>
-    (e->GetPrimitiveArrayCritical(buffer, 0));
+
+  uint8_t* dst
+      = reinterpret_cast<uint8_t*>(e->GetPrimitiveArrayCritical(buffer, 0));
 
   int64_t bytesRead = ::read(fd, dst + offset, length);
   e->ReleasePrimitiveArrayCritical(buffer, dst, 0);
-  
-  if(bytesRead == -1) {
+
+  if (bytesRead == -1) {
     throwNewErrno(e, "java/io/IOException");
     return -1;
   }
@@ -883,16 +915,16 @@ Java_java_io_RandomAccessFile_readBytes(JNIEnv* e, jclass, jlong peer,
   HANDLE hFile = (HANDLE)peer;
   LARGE_INTEGER lPos;
   lPos.QuadPart = position;
-  if(!SetFilePointerEx(hFile, lPos, nullptr, FILE_BEGIN)) {
+  if (!SetFilePointerEx(hFile, lPos, nullptr, FILE_BEGIN)) {
     throwNewErrno(e, "java/io/IOException");
     return -1;
   }
 
-  uint8_t* dst = reinterpret_cast<uint8_t*>
-    (e->GetPrimitiveArrayCritical(buffer, 0));
+  uint8_t* dst
+      = reinterpret_cast<uint8_t*>(e->GetPrimitiveArrayCritical(buffer, 0));
 
   DWORD bytesRead = 0;
-  if(!ReadFile(hFile, dst + offset, length, &bytesRead, nullptr)) {
+  if (!ReadFile(hFile, dst + offset, length, &bytesRead, nullptr)) {
     e->ReleasePrimitiveArrayCritical(buffer, dst, 0);
     throwNewErrno(e, "java/io/IOException");
     return -1;
@@ -904,24 +936,28 @@ Java_java_io_RandomAccessFile_readBytes(JNIEnv* e, jclass, jlong peer,
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_java_io_RandomAccessFile_writeBytes(JNIEnv* e, jclass, jlong peer,
-                                   jlong position, jbyteArray buffer,
-                                   int offset, int length)
+    Java_java_io_RandomAccessFile_writeBytes(JNIEnv* e,
+                                             jclass,
+                                             jlong peer,
+                                             jlong position,
+                                             jbyteArray buffer,
+                                             int offset,
+                                             int length)
 {
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
   int fd = (int)peer;
-  if(::lseek(fd, position, SEEK_SET) == -1) {
+  if (::lseek(fd, position, SEEK_SET) == -1) {
     throwNewErrno(e, "java/io/IOException");
     return -1;
   }
 
-  uint8_t* dst = reinterpret_cast<uint8_t*>
-    (e->GetPrimitiveArrayCritical(buffer, 0));
+  uint8_t* dst
+      = reinterpret_cast<uint8_t*>(e->GetPrimitiveArrayCritical(buffer, 0));
 
   int64_t bytesWritten = ::write(fd, dst + offset, length);
   e->ReleasePrimitiveArrayCritical(buffer, dst, 0);
 
-  if(bytesWritten == -1) {
+  if (bytesWritten == -1) {
     throwNewErrno(e, "java/io/IOException");
     return -1;
   }
@@ -929,16 +965,16 @@ Java_java_io_RandomAccessFile_writeBytes(JNIEnv* e, jclass, jlong peer,
   HANDLE hFile = (HANDLE)peer;
   LARGE_INTEGER lPos;
   lPos.QuadPart = position;
-  if(!SetFilePointerEx(hFile, lPos, nullptr, FILE_BEGIN)) {
+  if (!SetFilePointerEx(hFile, lPos, nullptr, FILE_BEGIN)) {
     throwNewErrno(e, "java/io/IOException");
     return -1;
   }
 
-  uint8_t* dst = reinterpret_cast<uint8_t*>
-    (e->GetPrimitiveArrayCritical(buffer, 0));
+  uint8_t* dst
+      = reinterpret_cast<uint8_t*>(e->GetPrimitiveArrayCritical(buffer, 0));
 
   DWORD bytesWritten = 0;
-  if(!WriteFile(hFile, dst + offset, length, &bytesWritten, nullptr)) {
+  if (!WriteFile(hFile, dst + offset, length, &bytesWritten, nullptr)) {
     e->ReleasePrimitiveArrayCritical(buffer, dst, 0);
     throwNewErrno(e, "java/io/IOException");
     return -1;
@@ -950,7 +986,7 @@ Java_java_io_RandomAccessFile_writeBytes(JNIEnv* e, jclass, jlong peer,
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_io_RandomAccessFile_close(JNIEnv* /* e*/, jclass, jlong peer)
+    Java_java_io_RandomAccessFile_close(JNIEnv* /* e*/, jclass, jlong peer)
 {
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
   int fd = (int)peer;
diff --git a/classpath/java-lang.cpp b/classpath/java-lang.cpp
index d96002c5bf..ae378e45d1 100644
--- a/classpath/java-lang.cpp
+++ b/classpath/java-lang.cpp
@@ -7,7 +7,7 @@
 
    There is NO WARRANTY for this software.  See license.txt for
    details. */
-   
+
 #include "math.h"
 #include "stdlib.h"
 #include "time.h"
@@ -21,63 +21,63 @@
 
 #ifdef PLATFORM_WINDOWS
 
-#  include "windows.h"
-#  include "winbase.h"
-#  include "io.h"
-#  include "tchar.h"
-#  include "float.h"
-#  include "sys/types.h"
-#  include "sys/timeb.h"
-#  define SO_PREFIX ""
-#  define SO_SUFFIX ".dll"
+#include "windows.h"
+#include "winbase.h"
+#include "io.h"
+#include "tchar.h"
+#include "float.h"
+#include "sys/types.h"
+#include "sys/timeb.h"
+#define SO_PREFIX ""
+#define SO_SUFFIX ".dll"
 
-#  ifdef _MSC_VER
-#    define snprintf sprintf_s
-#    define isnan _isnan
-#    define isfinite _finite
-#    define strtof strtod
-#  endif
+#ifdef _MSC_VER
+#define snprintf sprintf_s
+#define isnan _isnan
+#define isfinite _finite
+#define strtof strtod
+#endif
 
-#else // not PLATFORM_WINDOWS
+#else  // not PLATFORM_WINDOWS
 
-#  define SO_PREFIX "lib"
-#  ifdef __APPLE__
-#    define SO_SUFFIX ".jnilib"
-#    include <TargetConditionals.h>
-#    if !TARGET_IPHONE_SIMULATOR && !TARGET_OS_IPHONE
-#      include <CoreServices/CoreServices.h>
-#    endif
-#  else
-#    define SO_SUFFIX ".so"
-#  endif
-#  include "unistd.h"
-#  include "limits.h"
-#  include "signal.h"
-#  include "sys/time.h"
-#  include "sys/types.h"
-# ifndef __ANDROID__
-#  include "sys/sysctl.h"
-# endif
-#  include "sys/utsname.h"
-#  include "sys/wait.h"
+#define SO_PREFIX "lib"
+#ifdef __APPLE__
+#define SO_SUFFIX ".jnilib"
+#include <TargetConditionals.h>
+#if !TARGET_IPHONE_SIMULATOR && !TARGET_OS_IPHONE
+#include <CoreServices/CoreServices.h>
+#endif
+#else
+#define SO_SUFFIX ".so"
+#endif
+#include "unistd.h"
+#include "limits.h"
+#include "signal.h"
+#include "sys/time.h"
+#include "sys/types.h"
+#ifndef __ANDROID__
+#include "sys/sysctl.h"
+#endif
+#include "sys/utsname.h"
+#include "sys/wait.h"
 
-#endif // not PLATFORM_WINDOWS
+#endif  // not PLATFORM_WINDOWS
 
 #ifndef WINAPI_FAMILY
-#  ifndef WINAPI_PARTITION_DESKTOP
-#    define WINAPI_PARTITION_DESKTOP 1
-#  endif
+#ifndef WINAPI_PARTITION_DESKTOP
+#define WINAPI_PARTITION_DESKTOP 1
+#endif
 
-#  ifndef WINAPI_FAMILY_PARTITION
-#    define WINAPI_FAMILY_PARTITION(x) (x)
-#  endif
+#ifndef WINAPI_FAMILY_PARTITION
+#define WINAPI_FAMILY_PARTITION(x) (x)
+#endif
 #else
-#  if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
 
-#    include "avian-interop.h"
+#include "avian-interop.h"
 
-#  endif
-#endif // WINAPI_FAMILY
+#endif
+#endif  // WINAPI_FAMILY
 
 namespace {
 
@@ -129,91 +129,107 @@ void add(JNIEnv* e,
 }
 
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-  char* getErrorStr(DWORD err) {
-    LPSTR errorStr = 0;
-    if(!FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0, err, LANG_SYSTEM_DEFAULT, (LPSTR)&errorStr, 0, 0))
-    {
-      char* errStr = (char*) malloc(9 * sizeof(char));
-      snprintf(errStr, 9, "%d", (int) err);
-      return errStr;
-    }
-    char* errStr = strdup(errorStr);
-    LocalFree(errorStr);
+char* getErrorStr(DWORD err)
+{
+  LPSTR errorStr = 0;
+  if (!FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER
+                      | FORMAT_MESSAGE_FROM_SYSTEM
+                      | FORMAT_MESSAGE_IGNORE_INSERTS,
+                      0,
+                      err,
+                      LANG_SYSTEM_DEFAULT,
+                      (LPSTR)&errorStr,
+                      0,
+                      0)) {
+    char* errStr = (char*)malloc(9 * sizeof(char));
+    snprintf(errStr, 9, "%d", (int)err);
     return errStr;
   }
+  char* errStr = strdup(errorStr);
+  LocalFree(errorStr);
+  return errStr;
+}
 #else
-  char* getErrorStr(DWORD err) {
-    LPSTR errorStr = (LPSTR)malloc(4096); //NOTE: something constant
-    if(!FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0, err, LANG_SYSTEM_DEFAULT, errorStr, 0, 0))
-    {
-      free(errorStr);
-
-      char* errStr = (char*) malloc(9 * sizeof(char));
-      snprintf(errStr, 9, "%d", (int) err);
-      return errStr;
-    }
-    char* errStr = strdup(errorStr);
+char* getErrorStr(DWORD err)
+{
+  LPSTR errorStr = (LPSTR)malloc(4096);  // NOTE: something constant
+  if (!FormatMessageA(
+          FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+          0,
+          err,
+          LANG_SYSTEM_DEFAULT,
+          errorStr,
+          0,
+          0)) {
     free(errorStr);
+
+    char* errStr = (char*)malloc(9 * sizeof(char));
+    snprintf(errStr, 9, "%d", (int)err);
     return errStr;
   }
+  char* errStr = strdup(errorStr);
+  free(errorStr);
+  return errStr;
+}
 #endif
 
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-  void makePipe(JNIEnv* e, HANDLE p[2])
-  {
-    SECURITY_ATTRIBUTES sa;
-    sa.nLength = sizeof(sa);
-    sa.bInheritHandle = 1;
-    sa.lpSecurityDescriptor = 0;
-  
-    BOOL success = CreatePipe(p, p + 1, &sa, 0);
-    if (not success) {
-      throwNew(e, "java/io/IOException", getErrorStr(GetLastError()));
-    }
+void makePipe(JNIEnv* e, HANDLE p[2])
+{
+  SECURITY_ATTRIBUTES sa;
+  sa.nLength = sizeof(sa);
+  sa.bInheritHandle = 1;
+  sa.lpSecurityDescriptor = 0;
+
+  BOOL success = CreatePipe(p, p + 1, &sa, 0);
+  if (not success) {
+    throwNew(e, "java/io/IOException", getErrorStr(GetLastError()));
   }
+}
 #endif
-  
-  int descriptor(JNIEnv* e, HANDLE h)
-  {
-    int fd = _open_osfhandle(reinterpret_cast<intptr_t>(h), 0);
-    if (fd == -1) {
-      throwNewErrno(e, "java/io/IOException");
-    }
-    return fd;
+
+int descriptor(JNIEnv* e, HANDLE h)
+{
+  int fd = _open_osfhandle(reinterpret_cast<intptr_t>(h), 0);
+  if (fd == -1) {
+    throwNewErrno(e, "java/io/IOException");
   }
+  return fd;
+}
 #else
-  void makePipe(JNIEnv* e, int p[2])
-  {
-    if(pipe(p) != 0) {
-      throwNewErrno(e, "java/io/IOException");
-    }
+void makePipe(JNIEnv* e, int p[2])
+{
+  if (pipe(p) != 0) {
+    throwNewErrno(e, "java/io/IOException");
   }
-  
-  void safeClose(int &fd)
-  {
-    if(fd != -1) close(fd);
-    fd = -1;
-  }
-  
-  void close(int p[2])
-  {
-    ::close(p[0]);
-    ::close(p[1]);
-  }
-  
-  void clean(JNIEnv* e, jobjectArray command, char** p)
-  {
-    int i = 0;
-    for(char** x = p; *x; ++x, ++i){
-      jstring element = (jstring) e->GetObjectArrayElement(command, i);
-      e->ReleaseStringUTFChars(element, *x);
-    }
-    free(p);
-  }
-#endif  
 }
 
-class Locale { // represents an ISO two-char language/country pair
+void safeClose(int& fd)
+{
+  if (fd != -1)
+    close(fd);
+  fd = -1;
+}
+
+void close(int p[2])
+{
+  ::close(p[0]);
+  ::close(p[1]);
+}
+
+void clean(JNIEnv* e, jobjectArray command, char** p)
+{
+  int i = 0;
+  for (char** x = p; *x; ++x, ++i) {
+    jstring element = (jstring)e->GetObjectArrayElement(command, i);
+    e->ReleaseStringUTFChars(element, *x);
+  }
+  free(p);
+}
+#endif
+}
+
+class Locale {  // represents an ISO two-char language/country pair
   static const unsigned FIELDLEN = 2;
   static const unsigned FIELDSIZE = FIELDLEN + 1;
 
@@ -223,100 +239,120 @@ class Locale { // represents an ISO two-char language/country pair
   char language[FIELDSIZE];
   char region[FIELDSIZE];
 
-  bool isLanguage(const char* language) {
-    if (!language) return false;
+  bool isLanguage(const char* language)
+  {
+    if (!language)
+      return false;
     unsigned len = strlen(language);
-    if (len != FIELDLEN) return false;
+    if (len != FIELDLEN)
+      return false;
     const char* p = language - 1;
-    while (islower(*++p)) ;
-    if (*p != '\0') return false;
+    while (islower(*++p))
+      ;
+    if (*p != '\0')
+      return false;
     return true;
   }
 
-  bool isRegion(const char* region) {
-    if (!region) return false;
+  bool isRegion(const char* region)
+  {
+    if (!region)
+      return false;
     unsigned len = strlen(region);
-    if (len != FIELDLEN) return false;
+    if (len != FIELDLEN)
+      return false;
     const char* p = region - 1;
-    while (isupper(*++p)) ;
-    if (*p != '\0') return false;
+    while (isupper(*++p))
+      ;
+    if (*p != '\0')
+      return false;
     return true;
   }
 
-public:
-  Locale(const char* language = "") {
+ public:
+  Locale(const char* language = "")
+  {
     Locale l(language, "");
     *this = l;
   }
 
-  Locale(const char* language, const char* region) {
+  Locale(const char* language, const char* region)
+  {
     language = isLanguage(language) ? language : DEFAULT_LANGUAGE;
     region = isRegion(region) ? region : DEFAULT_REGION;
     memcpy(this->language, language, FIELDSIZE);
     memcpy(this->region, region, FIELDSIZE);
   }
 
-  Locale& operator=(const Locale& l) {
+  Locale& operator=(const Locale& l)
+  {
     memcpy(language, l.language, FIELDSIZE);
     memcpy(region, l.region, FIELDSIZE);
     return *this;
   }
 
-  const char* getLanguage() { return reinterpret_cast<const char*>(language); }
-  const char* getRegion() { return reinterpret_cast<const char*>(region); }
+  const char* getLanguage()
+  {
+    return reinterpret_cast<const char*>(language);
+  }
+  const char* getRegion()
+  {
+    return reinterpret_cast<const char*>(region);
+  }
 };
 const char* Locale::DEFAULT_LANGUAGE = "en";
 const char* Locale::DEFAULT_REGION = "";
 
 #ifdef PLATFORM_WINDOWS
 
-void appendN(char** dest, char ch, size_t length) {
-  for(size_t i = 0; i < length; i++) {
+void appendN(char** dest, char ch, size_t length)
+{
+  for (size_t i = 0; i < length; i++) {
     *((*dest)++) = ch;
   }
 }
 
-bool needsEscape(const char* src, size_t length) {
+bool needsEscape(const char* src, size_t length)
+{
   const char* end = src + length;
-  for(const char* ptr = src; ptr < end; ptr++) {
-    switch(*ptr) {
-      case ' ':
-      case '\t':
-      case '\n':
-      case '\v':
-      case '"':
-        return true;
+  for (const char* ptr = src; ptr < end; ptr++) {
+    switch (*ptr) {
+    case ' ':
+    case '\t':
+    case '\n':
+    case '\v':
+    case '"':
+      return true;
     }
   }
 
   return false;
-
 }
 
-void copyAndEscape(char** dest, const char* src, size_t length) {
+void copyAndEscape(char** dest, const char* src, size_t length)
+{
   char* destp = *dest;
   const char* end = src + length;
 
-  if(length != 0 && !needsEscape(src, length)) {
-    for(const char* ptr = src; ptr < end; ptr++) {
+  if (length != 0 && !needsEscape(src, length)) {
+    for (const char* ptr = src; ptr < end; ptr++) {
       *(destp++) = *ptr;
     }
   } else {
-
     *(destp++) = '"';
 
-    for(const char* ptr = src; ; ptr++) {
+    for (const char* ptr = src;; ptr++) {
       unsigned numBackslashes = 0;
 
-      while(ptr < end && *ptr == '\\') {
+      while (ptr < end && *ptr == '\\') {
         ptr++;
         numBackslashes++;
       }
 
-      if(ptr == end) {
+      if (ptr == end) {
         appendN(&destp, '\\', 2 * numBackslashes);
         break;
-      } else if(*ptr == '"') {
+      } else if (*ptr == '"') {
         appendN(&destp, '\\', 2 * numBackslashes + 1);
         *(destp++) = *ptr;
       } else {
@@ -324,65 +360,73 @@ void copyAndEscape(char** dest, const char* src, size_t length) {
         *(destp++) = *ptr;
       }
     }
-    
+
     *(destp++) = '"';
   }
 
   *dest = destp;
 }
 
-extern "C" JNIEXPORT void JNICALL 
-Java_java_lang_Runtime_exec(JNIEnv* e, jclass, 
-                            jobjectArray command, jlongArray process)
+extern "C" JNIEXPORT void JNICALL
+    Java_java_lang_Runtime_exec(JNIEnv* e,
+                                jclass,
+                                jobjectArray command,
+                                jlongArray process)
 {
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
   int size = 0;
-  for (int i = 0; i < e->GetArrayLength(command); ++i){
-    jstring element = (jstring) e->GetObjectArrayElement(command, i);
-    if(element) {
+  for (int i = 0; i < e->GetArrayLength(command); ++i) {
+    jstring element = (jstring)e->GetObjectArrayElement(command, i);
+    if (element) {
       // worst case, assuming every character is '"', and we escape all of them
       size += 2 * e->GetStringUTFLength(element) + 3;
     } else {
-      throwNew(e, "java/lang/NullPointerException", strdup("null string array element"));
+      throwNew(e,
+               "java/lang/NullPointerException",
+               strdup("null string array element"));
     }
   }
-   
+
   RUNTIME_ARRAY(char, line, size);
   char* linep = RUNTIME_ARRAY_BODY(line);
   for (int i = 0; i < e->GetArrayLength(command); ++i) {
-    if (i) *(linep++) = _T(' ');
-    jstring element = (jstring) e->GetObjectArrayElement(command, i);
-    const char* s =  e->GetStringUTFChars(element, 0);
+    if (i)
+      *(linep++) = _T(' ');
+    jstring element = (jstring)e->GetObjectArrayElement(command, i);
+    const char* s = e->GetStringUTFChars(element, 0);
 
     copyAndEscape(&linep, s, e->GetStringUTFLength(element));
 
     e->ReleaseStringUTFChars(element, s);
   }
   *(linep++) = _T('\0');
- 
-  HANDLE in[] = { 0, 0 };
-  HANDLE out[] = { 0, 0 };
-  HANDLE err[] = { 0, 0 };
-  
+
+  HANDLE in[] = {0, 0};
+  HANDLE out[] = {0, 0};
+  HANDLE err[] = {0, 0};
+
   makePipe(e, in);
   SetHandleInformation(in[0], HANDLE_FLAG_INHERIT, 0);
   jlong inDescriptor = static_cast<jlong>(descriptor(e, in[0]));
-  if(e->ExceptionCheck()) return;
+  if (e->ExceptionCheck())
+    return;
   e->SetLongArrayRegion(process, 2, 1, &inDescriptor);
   makePipe(e, out);
   SetHandleInformation(out[1], HANDLE_FLAG_INHERIT, 0);
   jlong outDescriptor = static_cast<jlong>(descriptor(e, out[1]));
-  if(e->ExceptionCheck()) return;
+  if (e->ExceptionCheck())
+    return;
   e->SetLongArrayRegion(process, 3, 1, &outDescriptor);
   makePipe(e, err);
   SetHandleInformation(err[0], HANDLE_FLAG_INHERIT, 0);
   jlong errDescriptor = static_cast<jlong>(descriptor(e, err[0]));
-  if(e->ExceptionCheck()) return;
+  if (e->ExceptionCheck())
+    return;
   e->SetLongArrayRegion(process, 4, 1, &errDescriptor);
-  
+
   PROCESS_INFORMATION pi;
   ZeroMemory(&pi, sizeof(pi));
- 
+
   STARTUPINFO si;
   ZeroMemory(&si, sizeof(si));
   si.cb = sizeof(si);
@@ -390,37 +434,44 @@ Java_java_lang_Runtime_exec(JNIEnv* e, jclass,
   si.hStdOutput = in[1];
   si.hStdInput = out[0];
   si.hStdError = err[1];
- 
-  BOOL success = CreateProcess(0, (LPSTR) RUNTIME_ARRAY_BODY(line), 0, 0, 1,
+
+  BOOL success = CreateProcess(0,
+                               (LPSTR)RUNTIME_ARRAY_BODY(line),
+                               0,
+                               0,
+                               1,
                                CREATE_NO_WINDOW | CREATE_UNICODE_ENVIRONMENT,
-                               0, 0, &si, &pi);
+                               0,
+                               0,
+                               &si,
+                               &pi);
 
   CloseHandle(in[1]);
   CloseHandle(out[0]);
   CloseHandle(err[1]);
-  
+
   if (not success) {
     throwNew(e, "java/io/IOException", getErrorStr(GetLastError()));
     return;
   }
-  
+
   jlong pid = reinterpret_cast<jlong>(pi.hProcess);
   e->SetLongArrayRegion(process, 0, 1, &pid);
-  jlong tid = reinterpret_cast<jlong>(pi.hThread);  
+  jlong tid = reinterpret_cast<jlong>(pi.hThread);
   e->SetLongArrayRegion(process, 1, 1, &tid);
 #else
   throwNew(e, "java/io/Exception", strdup("Not supported on WinRT/WinPhone8"));
 #endif
 }
 
-extern "C" JNIEXPORT jint JNICALL 
-Java_java_lang_Runtime_waitFor(JNIEnv* e, jclass, jlong pid, jlong tid)
+extern "C" JNIEXPORT jint JNICALL
+    Java_java_lang_Runtime_waitFor(JNIEnv* e, jclass, jlong pid, jlong tid)
 {
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
   DWORD exitCode;
   WaitForSingleObject(reinterpret_cast<HANDLE>(pid), INFINITE);
   BOOL success = GetExitCodeProcess(reinterpret_cast<HANDLE>(pid), &exitCode);
-  if(not success){
+  if (not success) {
     throwNew(e, "java/lang/Exception", getErrorStr(GetLastError()));
   }
 
@@ -435,7 +486,8 @@ Java_java_lang_Runtime_waitFor(JNIEnv* e, jclass, jlong pid, jlong tid)
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_lang_Runtime_kill(JNIEnv* e UNUSED, jclass, jlong pid) {
+    Java_java_lang_Runtime_kill(JNIEnv* e UNUSED, jclass, jlong pid)
+{
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
   TerminateProcess(reinterpret_cast<HANDLE>(pid), 1);
 #else
@@ -443,7 +495,8 @@ Java_java_lang_Runtime_kill(JNIEnv* e UNUSED, jclass, jlong pid) {
 #endif
 }
 
-Locale getLocale() {
+Locale getLocale()
+{
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
   const char* lang = "";
   const char* reg = "";
@@ -452,77 +505,151 @@ Locale getLocale() {
   unsigned sublang = langid >> 10;
 
   switch (prilang) {
-    case 0x004: {
-      lang = "zh";
-      switch (sublang) {
-        case 0x01: reg = "CN"; break;
-        case 0x02: reg = "TW"; break;
-        case 0x03: reg = "HK"; break;
-        case 0x04: reg = "SG"; break;
-      }
-    } break;
-    case 0x006: lang = "da"; reg = "DK"; break;
-    case 0x007: lang = "de"; reg = "DE"; break;
-    case 0x009: {
-      lang = "en";
-      switch (sublang) {
-        case 0x01: reg = "US"; break;
-        case 0x02: reg = "GB"; break;
-        case 0x03: reg = "AU"; break;
-        case 0x04: reg = "CA"; break;
-        case 0x05: reg = "NZ"; break;
-        case 0x06: reg = "IE"; break;
-        case 0x07: reg = "ZA"; break;
-        case 0x10: reg = "IN"; break;
-      }
-    } break;
-    case 0x00a: {
-      lang = "es";
-      switch (sublang) {
-        case 0x01: case 0x03: reg = "ES"; break;
-        case 0x02: reg = "MX"; break;
-      }
-    } break;
-    case 0x00c: {
-      lang = "fr";
-      switch (sublang) {
-        case 0x01: reg = "FR"; break;
-        case 0x02: reg = "BE"; break;
-        case 0x03: reg = "CA"; break;
-      }
-    } break;
-    case 0x010: lang = "it"; reg = "IT"; break;
-    case 0x011: lang = "ja"; reg = "JP"; break;
-    case 0x012: lang = "ko"; reg = "KR"; break;
-    case 0x013: {
-      lang = "nl";
-      switch (sublang) {
-        case 0x01: reg = "NL"; break;
-        case 0x02: reg = "BE"; break;
-      }
-    } break;
-    case 0x014: lang = "no"; reg = "NO"; break;
-    case 0x015: lang = "pl"; reg = "PL"; break;
-    case 0x016: {
-      lang = "pt";
-      switch (sublang) {
-        case 0x01: reg = "BR"; break;
-        case 0x02: reg = "PT"; break;
-      }
-    } break;
-    case 0x018: lang = "ro"; reg = "RO"; break;
-    case 0x019: lang = "ru"; reg = "RU"; break;
-    case 0x01d: lang = "sv"; reg = "SE"; break;
-    default: lang = "en";
+  case 0x004: {
+    lang = "zh";
+    switch (sublang) {
+    case 0x01:
+      reg = "CN";
+      break;
+    case 0x02:
+      reg = "TW";
+      break;
+    case 0x03:
+      reg = "HK";
+      break;
+    case 0x04:
+      reg = "SG";
+      break;
+    }
+  } break;
+  case 0x006:
+    lang = "da";
+    reg = "DK";
+    break;
+  case 0x007:
+    lang = "de";
+    reg = "DE";
+    break;
+  case 0x009: {
+    lang = "en";
+    switch (sublang) {
+    case 0x01:
+      reg = "US";
+      break;
+    case 0x02:
+      reg = "GB";
+      break;
+    case 0x03:
+      reg = "AU";
+      break;
+    case 0x04:
+      reg = "CA";
+      break;
+    case 0x05:
+      reg = "NZ";
+      break;
+    case 0x06:
+      reg = "IE";
+      break;
+    case 0x07:
+      reg = "ZA";
+      break;
+    case 0x10:
+      reg = "IN";
+      break;
+    }
+  } break;
+  case 0x00a: {
+    lang = "es";
+    switch (sublang) {
+    case 0x01:
+    case 0x03:
+      reg = "ES";
+      break;
+    case 0x02:
+      reg = "MX";
+      break;
+    }
+  } break;
+  case 0x00c: {
+    lang = "fr";
+    switch (sublang) {
+    case 0x01:
+      reg = "FR";
+      break;
+    case 0x02:
+      reg = "BE";
+      break;
+    case 0x03:
+      reg = "CA";
+      break;
+    }
+  } break;
+  case 0x010:
+    lang = "it";
+    reg = "IT";
+    break;
+  case 0x011:
+    lang = "ja";
+    reg = "JP";
+    break;
+  case 0x012:
+    lang = "ko";
+    reg = "KR";
+    break;
+  case 0x013: {
+    lang = "nl";
+    switch (sublang) {
+    case 0x01:
+      reg = "NL";
+      break;
+    case 0x02:
+      reg = "BE";
+      break;
+    }
+  } break;
+  case 0x014:
+    lang = "no";
+    reg = "NO";
+    break;
+  case 0x015:
+    lang = "pl";
+    reg = "PL";
+    break;
+  case 0x016: {
+    lang = "pt";
+    switch (sublang) {
+    case 0x01:
+      reg = "BR";
+      break;
+    case 0x02:
+      reg = "PT";
+      break;
+    }
+  } break;
+  case 0x018:
+    lang = "ro";
+    reg = "RO";
+    break;
+  case 0x019:
+    lang = "ru";
+    reg = "RU";
+    break;
+  case 0x01d:
+    lang = "sv";
+    reg = "SE";
+    break;
+  default:
+    lang = "en";
   }
 
   return Locale(lang, reg);
 #else
   std::wstring culture = AvianInterop::GetCurrentUICulture();
-  char* cultureName = strdup(std::string(culture.begin(), culture.end()).c_str());
+  char* cultureName
+      = strdup(std::string(culture.begin(), culture.end()).c_str());
   char* delimiter = strchr(cultureName, '-');
-  if(!delimiter)
-  {
+  if (!delimiter) {
     free(cultureName);
     return Locale("en", "US");
   }
@@ -535,44 +662,50 @@ Locale getLocale() {
 #endif
 }
 #else
-extern "C" JNIEXPORT void JNICALL 
-Java_java_lang_Runtime_exec(JNIEnv* e, jclass, 
-                            jobjectArray command, jlongArray process)
+extern "C" JNIEXPORT void JNICALL
+    Java_java_lang_Runtime_exec(JNIEnv* e,
+                                jclass,
+                                jobjectArray command,
+                                jlongArray process)
 {
-  char** argv = static_cast<char**>
-    (malloc((e->GetArrayLength(command) + 1) * sizeof(char*)));
+  char** argv = static_cast<char**>(
+      malloc((e->GetArrayLength(command) + 1) * sizeof(char*)));
   int i;
-  for(i = 0; i < e->GetArrayLength(command); i++){
-    jstring element = (jstring) e->GetObjectArrayElement(command, i);
+  for (i = 0; i < e->GetArrayLength(command); i++) {
+    jstring element = (jstring)e->GetObjectArrayElement(command, i);
     char* s = const_cast<char*>(e->GetStringUTFChars(element, 0));
     argv[i] = s;
   }
   argv[i] = 0;
-  
-  int in[] = { -1, -1 };
-  int out[] = { -1, -1 };
-  int err[] = { -1, -1 };
-  int msg[] = { -1, -1 };
-  
+
+  int in[] = {-1, -1};
+  int out[] = {-1, -1};
+  int err[] = {-1, -1};
+  int msg[] = {-1, -1};
+
   makePipe(e, in);
-  if(e->ExceptionCheck()) return;
+  if (e->ExceptionCheck())
+    return;
   jlong inDescriptor = static_cast<jlong>(in[0]);
   e->SetLongArrayRegion(process, 2, 1, &inDescriptor);
   makePipe(e, out);
-  if(e->ExceptionCheck()) return;
+  if (e->ExceptionCheck())
+    return;
   jlong outDescriptor = static_cast<jlong>(out[1]);
   e->SetLongArrayRegion(process, 3, 1, &outDescriptor);
   makePipe(e, err);
-  if(e->ExceptionCheck()) return;
+  if (e->ExceptionCheck())
+    return;
   jlong errDescriptor = static_cast<jlong>(err[0]);
   e->SetLongArrayRegion(process, 4, 1, &errDescriptor);
   makePipe(e, msg);
-  if(e->ExceptionCheck()) return;
-  if(fcntl(msg[1], F_SETFD, FD_CLOEXEC) != 0) {
+  if (e->ExceptionCheck())
+    return;
+  if (fcntl(msg[1], F_SETFD, FD_CLOEXEC) != 0) {
     throwNewErrno(e, "java/io/IOException");
     return;
   }
-  
+
 #ifdef __QNX__
   // fork(2) doesn't work in multithreaded QNX programs.  See
   // http://www.qnx.com/developers/docs/6.4.1/neutrino/getting_started/s1_procs.html
@@ -583,11 +716,11 @@ Java_java_lang_Runtime_exec(JNIEnv* e, jclass,
   // parent/child address space, so we use fork if we can.
   pid_t pid = fork();
 #endif
-  switch(pid){
-  case -1: // error
+  switch (pid) {
+  case -1:  // error
     throwNewErrno(e, "java/io/IOException");
     return;
-  case 0: { // child
+  case 0: {  // child
     // Setup stdin, stdout and stderr
     dup2(in[1], 1);
     close(in);
@@ -596,90 +729,97 @@ Java_java_lang_Runtime_exec(JNIEnv* e, jclass,
     dup2(err[1], 2);
     close(err);
     close(msg[0]);
-    
+
     execvp(argv[0], argv);
-    
+
     // Error if here
     int val = errno;
     ssize_t rv UNUSED = write(msg[1], &val, sizeof(val));
     exit(127);
   } break;
-    
-  default: { //parent
+
+  default: {  // parent
     jlong JNIPid = static_cast<jlong>(pid);
     e->SetLongArrayRegion(process, 0, 1, &JNIPid);
-    
+
     safeClose(in[1]);
     safeClose(out[0]);
     safeClose(err[1]);
     safeClose(msg[1]);
-      
+
     int val;
     int r = read(msg[0], &val, sizeof(val));
-    if(r == -1) {
+    if (r == -1) {
       throwNewErrno(e, "java/io/IOException");
       return;
-    } else if(r) {
+    } else if (r) {
       errno = val;
       throwNewErrno(e, "java/io/IOException");
       return;
     }
   } break;
   }
-  
+
   safeClose(msg[0]);
   clean(e, command, argv);
-  
+
   fcntl(in[0], F_SETFD, FD_CLOEXEC);
   fcntl(out[1], F_SETFD, FD_CLOEXEC);
   fcntl(err[0], F_SETFD, FD_CLOEXEC);
 }
 
-extern "C" JNIEXPORT jint JNICALL 
-Java_java_lang_Runtime_waitFor(JNIEnv*, jclass, jlong pid, jlong)
+extern "C" JNIEXPORT jint JNICALL
+    Java_java_lang_Runtime_waitFor(JNIEnv*, jclass, jlong pid, jlong)
 {
   bool finished = false;
   int status;
   int exitCode;
-  while(!finished){
+  while (!finished) {
     waitpid(pid, &status, 0);
-    if(WIFEXITED(status)){
+    if (WIFEXITED(status)) {
       finished = true;
       exitCode = WEXITSTATUS(status);
-    } else if(WIFSIGNALED(status)){
+    } else if (WIFSIGNALED(status)) {
       finished = true;
       exitCode = -1;
     }
   }
-  
+
   return exitCode;
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_lang_Runtime_kill(JNIEnv*, jclass, jlong pid) {
+    Java_java_lang_Runtime_kill(JNIEnv*, jclass, jlong pid)
+{
   kill((pid_t)pid, SIGTERM);
 }
 
-Locale getLocale() {
+Locale getLocale()
+{
   Locale fallback;
 
   const char* LANG = getenv("LANG");
-  if (!LANG || strcmp(LANG, "C") == 0) return fallback;
+  if (!LANG || strcmp(LANG, "C") == 0)
+    return fallback;
 
   int len = strlen(LANG);
-  char buf[len + 1]; // + 1 for the '\0' char
+  char buf[len + 1];  // + 1 for the '\0' char
   memcpy(buf, LANG, len + 1);
 
   char* tracer = buf;
   const char* reg;
 
-  while (*tracer && *tracer != '_') ++tracer;
-  if (!*tracer) return fallback;
+  while (*tracer && *tracer != '_')
+    ++tracer;
+  if (!*tracer)
+    return fallback;
   *tracer = '\0';
   reg = ++tracer;
 
-  while (*tracer && *tracer != '.') ++tracer;
-  if (tracer == reg) return fallback;
+  while (*tracer && *tracer != '.')
+    ++tracer;
+  if (tracer == reg)
+    return fallback;
   *tracer = '\0';
 
   Locale locale(buf, reg);
@@ -715,20 +855,20 @@ extern "C" JNIEXPORT jobjectArray JNICALL
 
   e->SetObjectArrayElement(array, index++, e->NewStringUTF("path.separator=;"));
 
-#  if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
   e->SetObjectArrayElement(array, index++, e->NewStringUTF("os.name=Windows"));
 
-#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE)
+#elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE)
   e->SetObjectArrayElement(
       array, index++, e->NewStringUTF("os.name=Windows Phone"));
 
-#  else
+#else
   e->SetObjectArrayElement(
       array, index++, e->NewStringUTF("os.name=Windows RT"));
 
-#  endif
+#endif
 
-#  if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
   {
     OSVERSIONINFO OSversion;
     OSversion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
@@ -742,45 +882,45 @@ extern "C" JNIEXPORT jobjectArray JNICALL
         static_cast<int>(OSversion.dwMinorVersion));
   }
 
-#  else
+#else
   // Currently there is no alternative on WinRT/WP8
   e->SetObjectArrayElement(array, index++, e->NewStringUTF("os.version=8.0"));
 
-#  endif
+#endif
 
-#  if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
   {
     WCHAR buffer[MAX_PATH];
     GetTempPathW(MAX_PATH, buffer);
     add(e, array, index++, L"java.io.tmpdir=%ls", buffer);
   }
 
-#  else
+#else
   add(e,
       array,
       index++,
       L"java.io.tmpdir=%ls",
       AvianInterop::GetTemporaryFolder().c_str());
 
-#  endif
+#endif
 
-#  if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
   {
     WCHAR buffer[MAX_PATH];
     GetCurrentDirectoryW(MAX_PATH, buffer);
     add(e, array, index++, L"user.dir=%ls", buffer);
   }
 
-#  else
+#else
   add(e,
       array,
       index++,
       L"user.dir=%ls",
       AvianInterop::GetInstalledLocation().c_str());
 
-#  endif
+#endif
 
-#    if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
 #ifdef _MSC_VER
   {
     WCHAR buffer[MAX_PATH];
@@ -794,14 +934,14 @@ extern "C" JNIEXPORT jobjectArray JNICALL
   add(e, array, index++, L"user.home=%ls", _wgetenv(L"USERPROFILE"));
 
 #endif
-#    else
+#else
   add(e,
       array,
       index++,
       L"user.home=%ls",
       AvianInterop::GetDocumentsLibraryLocation().c_str());
 
-#    endif
+#endif
 
 #else  // not Windows
   e->SetObjectArrayElement(
@@ -853,25 +993,27 @@ extern "C" JNIEXPORT jobjectArray JNICALL
 // support (neither of which is likely to be of great importance).
 #ifdef AVIAN_IOS
 namespace {
-  const char* environ[] = { 0 };
+const char* environ[] = {0};
 }
 #elif defined __APPLE__
-#  include <crt_externs.h>
-#  define environ (*_NSGetEnviron())
-#elif defined(WINAPI_FAMILY) && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#include <crt_externs.h>
+#define environ (*_NSGetEnviron())
+#elif defined(WINAPI_FAMILY) \
+    && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
 // WinRT/WP8 does not provide alternative for environment variables
-char* environ[] = { 0 };
+char* environ[] = {0};
 #else
 extern char** environ;
 #endif
 extern "C" JNIEXPORT jobjectArray JNICALL
-Java_java_lang_System_getEnvironment(JNIEnv* env, jclass) {
+    Java_java_lang_System_getEnvironment(JNIEnv* env, jclass)
+{
   int length;
-  for (length = 0; environ[length] != 0; ++length) ;
+  for (length = 0; environ[length] != 0; ++length)
+    ;
 
-  jobjectArray stringArray =
-    env->NewObjectArray(length, env->FindClass("java/lang/String"),
-                        env->NewStringUTF(""));
+  jobjectArray stringArray = env->NewObjectArray(
+      length, env->FindClass("java/lang/String"), env->NewStringUTF(""));
 
   for (int i = 0; i < length; i++) {
     jobject varString = env->NewStringUTF(environ[i]);
@@ -882,7 +1024,7 @@ Java_java_lang_System_getEnvironment(JNIEnv* env, jclass) {
 }
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_java_lang_System_currentTimeMillis(JNIEnv*, jclass)
+    Java_java_lang_System_currentTimeMillis(JNIEnv*, jclass)
 {
 #ifdef PLATFORM_WINDOWS
   // We used to use _ftime here, but that only gives us 1-second
@@ -890,18 +1032,18 @@ Java_java_lang_System_currentTimeMillis(JNIEnv*, jclass)
   // doesn't have it as of this writing.  So we use this mess instead:
   FILETIME time;
   GetSystemTimeAsFileTime(&time);
-  return (((static_cast<jlong>(time.dwHighDateTime) << 32)
-           | time.dwLowDateTime) / 10000) - 11644473600000LL;
+  return (((static_cast<jlong>(time.dwHighDateTime) << 32) | time.dwLowDateTime)
+          / 10000) - 11644473600000LL;
 #else
-  timeval tv = { 0, 0 };
+  timeval tv = {0, 0};
   gettimeofday(&tv, 0);
-  return (static_cast<jlong>(tv.tv_sec) * 1000) +
-    (static_cast<jlong>(tv.tv_usec) / 1000);
+  return (static_cast<jlong>(tv.tv_sec) * 1000)
+         + (static_cast<jlong>(tv.tv_usec) / 1000);
 #endif
 }
 
 extern "C" JNIEXPORT jstring JNICALL
-Java_java_lang_System_doMapLibraryName(JNIEnv* e, jclass, jstring name)
+    Java_java_lang_System_doMapLibraryName(JNIEnv* e, jclass, jstring name)
 {
   jstring r = 0;
   const char* chars = e->GetStringUTFChars(name, 0);
@@ -909,8 +1051,7 @@ Java_java_lang_System_doMapLibraryName(JNIEnv* e, jclass, jstring name)
     unsigned nameLength = strlen(chars);
     unsigned size = sizeof(SO_PREFIX) + nameLength + sizeof(SO_SUFFIX);
     RUNTIME_ARRAY(char, buffer, size);
-    snprintf
-      (RUNTIME_ARRAY_BODY(buffer), size, SO_PREFIX "%s" SO_SUFFIX, chars);
+    snprintf(RUNTIME_ARRAY_BODY(buffer), size, SO_PREFIX "%s" SO_SUFFIX, chars);
     r = e->NewStringUTF(RUNTIME_ARRAY_BODY(buffer));
 
     e->ReleaseStringUTFChars(name, chars);
@@ -919,20 +1060,22 @@ Java_java_lang_System_doMapLibraryName(JNIEnv* e, jclass, jstring name)
 }
 
 extern "C" JNIEXPORT jboolean JNICALL
-Java_java_lang_Double_isInfinite(JNIEnv*, jclass, jdouble val)
+    Java_java_lang_Double_isInfinite(JNIEnv*, jclass, jdouble val)
 {
   return !isfinite(val);
 }
 
 extern "C" JNIEXPORT jboolean JNICALL
-Java_java_lang_Double_isNaN(JNIEnv*, jclass, jdouble val)
+    Java_java_lang_Double_isNaN(JNIEnv*, jclass, jdouble val)
 {
   return isnan(val);
 }
 
 extern "C" JNIEXPORT jdouble JNICALL
-Java_java_lang_Double_doubleFromString(JNIEnv*e, jclass, jstring s,
-				       jintArray numDoublesRead)
+    Java_java_lang_Double_doubleFromString(JNIEnv* e,
+                                           jclass,
+                                           jstring s,
+                                           jintArray numDoublesRead)
 {
   const char* chars = e->GetStringUTFChars(s, 0);
   double d = 0.0;
@@ -951,20 +1094,22 @@ Java_java_lang_Double_doubleFromString(JNIEnv*e, jclass, jstring s,
 }
 
 extern "C" JNIEXPORT jboolean JNICALL
-Java_java_lang_Float_isInfinite(JNIEnv*, jclass, jfloat val)
+    Java_java_lang_Float_isInfinite(JNIEnv*, jclass, jfloat val)
 {
   return !isfinite(val);
 }
 
 extern "C" JNIEXPORT jboolean JNICALL
-Java_java_lang_Float_isNaN(JNIEnv*, jclass, jfloat val)
+    Java_java_lang_Float_isNaN(JNIEnv*, jclass, jfloat val)
 {
   return isnan(val);
 }
 
 extern "C" JNIEXPORT jfloat JNICALL
-Java_java_lang_Float_floatFromString(JNIEnv*e, jclass, jstring s,
-				     jintArray numFloatsRead)
+    Java_java_lang_Float_floatFromString(JNIEnv* e,
+                                         jclass,
+                                         jstring s,
+                                         jintArray numFloatsRead)
 {
   const char* chars = e->GetStringUTFChars(s, 0);
   float f = 0.0;
@@ -983,104 +1128,108 @@ Java_java_lang_Float_floatFromString(JNIEnv*e, jclass, jstring s,
 }
 
 extern "C" JNIEXPORT jdouble JNICALL
-Java_java_lang_Math_sin(JNIEnv*, jclass, jdouble val)
+    Java_java_lang_Math_sin(JNIEnv*, jclass, jdouble val)
 {
   return sin(val);
 }
 
 extern "C" JNIEXPORT jdouble JNICALL
-Java_java_lang_Math_cos(JNIEnv*, jclass, jdouble val)
+    Java_java_lang_Math_cos(JNIEnv*, jclass, jdouble val)
 {
   return cos(val);
 }
 
 extern "C" JNIEXPORT jdouble JNICALL
-Java_java_lang_Math_tan(JNIEnv*, jclass, jdouble val)
+    Java_java_lang_Math_tan(JNIEnv*, jclass, jdouble val)
 {
   return tan(val);
 }
 
 extern "C" JNIEXPORT jdouble JNICALL
-Java_java_lang_Math_asin(JNIEnv*, jclass, jdouble val)
+    Java_java_lang_Math_asin(JNIEnv*, jclass, jdouble val)
 {
   return asin(val);
 }
 
 extern "C" JNIEXPORT jdouble JNICALL
-Java_java_lang_Math_acos(JNIEnv*, jclass, jdouble val)
+    Java_java_lang_Math_acos(JNIEnv*, jclass, jdouble val)
 {
   return acos(val);
 }
 
 extern "C" JNIEXPORT jdouble JNICALL
-Java_java_lang_Math_atan(JNIEnv*, jclass, jdouble val)
+    Java_java_lang_Math_atan(JNIEnv*, jclass, jdouble val)
 {
   return atan(val);
 }
 
 extern "C" JNIEXPORT jdouble JNICALL
-Java_java_lang_Math_atan2(JNIEnv*, jclass, jdouble y, jdouble x)
+    Java_java_lang_Math_atan2(JNIEnv*, jclass, jdouble y, jdouble x)
 {
   return atan2(y, x);
 }
 
 extern "C" JNIEXPORT jdouble JNICALL
-Java_java_lang_Math_sinh(JNIEnv*, jclass, jdouble val)
+    Java_java_lang_Math_sinh(JNIEnv*, jclass, jdouble val)
 {
   return sinh(val);
 }
 
 extern "C" JNIEXPORT jdouble JNICALL
-Java_java_lang_Math_cosh(JNIEnv*, jclass, jdouble val)
+    Java_java_lang_Math_cosh(JNIEnv*, jclass, jdouble val)
 {
   return cosh(val);
 }
 
 extern "C" JNIEXPORT jdouble JNICALL
-Java_java_lang_Math_tanh(JNIEnv*, jclass, jdouble val)
+    Java_java_lang_Math_tanh(JNIEnv*, jclass, jdouble val)
 {
   return tanh(val);
 }
 
 extern "C" JNIEXPORT jdouble JNICALL
-Java_java_lang_Math_sqrt(JNIEnv*, jclass, jdouble val)
+    Java_java_lang_Math_sqrt(JNIEnv*, jclass, jdouble val)
 {
   return sqrt(val);
 }
 
 extern "C" JNIEXPORT jdouble JNICALL
-Java_java_lang_Math_pow(JNIEnv*, jclass, jdouble val, jdouble exp)
+    Java_java_lang_Math_pow(JNIEnv*, jclass, jdouble val, jdouble exp)
 {
   return pow(val, exp);
 }
 
 extern "C" JNIEXPORT jdouble JNICALL
-Java_java_lang_Math_log(JNIEnv*, jclass, jdouble val)
+    Java_java_lang_Math_log(JNIEnv*, jclass, jdouble val)
 {
   return log(val);
 }
 
 extern "C" JNIEXPORT jdouble JNICALL
-Java_java_lang_Math_floor(JNIEnv*, jclass, jdouble val)
+    Java_java_lang_Math_floor(JNIEnv*, jclass, jdouble val)
 {
   return floor(val);
 }
 
 extern "C" JNIEXPORT jdouble JNICALL
-Java_java_lang_Math_ceil(JNIEnv*, jclass, jdouble val)
+    Java_java_lang_Math_ceil(JNIEnv*, jclass, jdouble val)
 {
   return ceil(val);
 }
 
 extern "C" JNIEXPORT jdouble JNICALL
-Java_java_lang_Math_exp(JNIEnv*, jclass, jdouble exp)
+    Java_java_lang_Math_exp(JNIEnv*, jclass, jdouble exp)
 {
   return pow(M_E, exp);
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_java_lang_Double_fillBufferWithDouble(JNIEnv* e, jclass, jdouble val,
-					   jbyteArray buffer, jint bufferSize) {
+    Java_java_lang_Double_fillBufferWithDouble(JNIEnv* e,
+                                               jclass,
+                                               jdouble val,
+                                               jbyteArray buffer,
+                                               jint bufferSize)
+{
   jboolean isCopy;
   jbyte* buf = e->GetByteArrayElements(buffer, &isCopy);
   jint count = snprintf(reinterpret_cast<char*>(buf), bufferSize, "%g", val);
diff --git a/classpath/java-net.cpp b/classpath/java-net.cpp
index 1fb2d64504..b6eaca086f 100644
--- a/classpath/java-net.cpp
+++ b/classpath/java-net.cpp
@@ -15,72 +15,87 @@
 
 using namespace avian::classpath::sockets;
 
-extern "C" JNIEXPORT void JNICALL
-Java_java_net_Socket_init(JNIEnv* e, jclass) {
-	init(e);
+extern "C" JNIEXPORT void JNICALL Java_java_net_Socket_init(JNIEnv* e, jclass)
+{
+  init(e);
 }
 
 extern "C" JNIEXPORT SOCKET JNICALL
-Java_java_net_Socket_create(JNIEnv* e, jclass) {
-	return create(e);
+    Java_java_net_Socket_create(JNIEnv* e, jclass)
+{
+  return create(e);
+}
+
+extern "C" JNIEXPORT void JNICALL Java_java_net_Socket_connect(JNIEnv* e,
+                                                               jclass,
+                                                               SOCKET sock,
+                                                               long addr,
+                                                               short port)
+{
+  connect(e, sock, addr, port);
+}
+
+extern "C" JNIEXPORT void JNICALL Java_java_net_Socket_bind(JNIEnv* e,
+                                                            jclass,
+                                                            SOCKET sock,
+                                                            long addr,
+                                                            short port)
+{
+  bind(e, sock, addr, port);
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_net_Socket_connect(JNIEnv* e, jclass, SOCKET sock, long addr, short port) {
-	connect(e, sock, addr, port);
+    Java_java_net_Socket_abort(JNIEnv* e, jclass, SOCKET sock)
+{
+  abort(e, sock);
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_net_Socket_bind(JNIEnv* e, jclass, SOCKET sock, long addr, short port) {
-	bind(e, sock, addr, port);
+    Java_java_net_Socket_close(JNIEnv* e, jclass, SOCKET sock)
+{
+  close(e, sock);
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_net_Socket_abort(JNIEnv* e, jclass, SOCKET sock) {
-	abort(e, sock);
+    Java_java_net_Socket_closeOutput(JNIEnv* e, jclass, SOCKET sock)
+{
+  close_output(e, sock);
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_net_Socket_close(JNIEnv* e, jclass, SOCKET sock) {
-	close(e, sock);
+    Java_java_net_Socket_closeInput(JNIEnv* e, jclass, SOCKET sock)
+{
+  close_input(e, sock);
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_net_Socket_closeOutput(JNIEnv* e, jclass, SOCKET sock) {
-	close_output(e, sock);
-}
-
-extern "C" JNIEXPORT void JNICALL
-Java_java_net_Socket_closeInput(JNIEnv* e, jclass, SOCKET sock) {
-	close_input(e, sock);
-}
-
-extern "C" JNIEXPORT void JNICALL
-Avian_java_net_Socket_send(vm::Thread* t, vm::object, uintptr_t* arguments) {		/* SOCKET s, object buffer_obj, int start_pos, int count  */
-	SOCKET& s = *(reinterpret_cast<SOCKET*>(&arguments[0]));
-        vm::GcByteArray* buffer_obj = vm::cast<vm::GcByteArray>(
-            t, reinterpret_cast<vm::object>(arguments[2]));
-        int32_t& start_pos = *(reinterpret_cast<int32_t*>(&arguments[3]));
-	int32_t& count = *(reinterpret_cast<int32_t*>(&arguments[4]));
-        char* buffer = reinterpret_cast<char*>(&buffer_obj->body()[start_pos]);
-        avian::classpath::sockets::send((JNIEnv*)t, s, buffer, count);
+    Avian_java_net_Socket_send(vm::Thread* t, vm::object, uintptr_t* arguments)
+{ /* SOCKET s, object buffer_obj, int start_pos, int count  */
+  SOCKET& s = *(reinterpret_cast<SOCKET*>(&arguments[0]));
+  vm::GcByteArray* buffer_obj = vm::cast<vm::GcByteArray>(
+      t, reinterpret_cast<vm::object>(arguments[2]));
+  int32_t& start_pos = *(reinterpret_cast<int32_t*>(&arguments[3]));
+  int32_t& count = *(reinterpret_cast<int32_t*>(&arguments[4]));
+  char* buffer = reinterpret_cast<char*>(&buffer_obj->body()[start_pos]);
+  avian::classpath::sockets::send((JNIEnv*)t, s, buffer, count);
 }
 
 extern "C" JNIEXPORT int64_t JNICALL
-Avian_java_net_Socket_recv(vm::Thread* t, vm::object, uintptr_t* arguments) {		/* SOCKET s, object buffer_obj, int start_pos, int count  */
-	SOCKET& s = *(reinterpret_cast<SOCKET*>(&arguments[0]));
-        vm::GcByteArray* buffer_obj = vm::cast<vm::GcByteArray>(
-            t, reinterpret_cast<vm::object>(arguments[2]));
-        int32_t& start_pos = *(reinterpret_cast<int32_t*>(&arguments[3]));
-	int32_t& count = *(reinterpret_cast<int32_t*>(&arguments[4]));
-        char* buffer = reinterpret_cast<char*>(&buffer_obj->body()[start_pos]);
-        return avian::classpath::sockets::recv((JNIEnv*)t, s, buffer, count);
+    Avian_java_net_Socket_recv(vm::Thread* t, vm::object, uintptr_t* arguments)
+{ /* SOCKET s, object buffer_obj, int start_pos, int count  */
+  SOCKET& s = *(reinterpret_cast<SOCKET*>(&arguments[0]));
+  vm::GcByteArray* buffer_obj = vm::cast<vm::GcByteArray>(
+      t, reinterpret_cast<vm::object>(arguments[2]));
+  int32_t& start_pos = *(reinterpret_cast<int32_t*>(&arguments[3]));
+  int32_t& count = *(reinterpret_cast<int32_t*>(&arguments[4]));
+  char* buffer = reinterpret_cast<char*>(&buffer_obj->body()[start_pos]);
+  return avian::classpath::sockets::recv((JNIEnv*)t, s, buffer, count);
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_java_net_InetAddress_ipv4AddressForName(JNIEnv* e,
-                                             jclass,
-                                             jstring name)
+    Java_java_net_InetAddress_ipv4AddressForName(JNIEnv* e,
+                                                 jclass,
+                                                 jstring name)
 {
   const char* chars = e->GetStringUTFChars(name, 0);
   if (chars) {
@@ -107,8 +122,8 @@ Java_java_net_InetAddress_ipv4AddressForName(JNIEnv* e,
       throwNew(e, "java/net/UnknownHostException", 0);
       return 0;
     } else {
-      int address = ntohl
-        (reinterpret_cast<sockaddr_in*>(result->ai_addr)->sin_addr.s_addr);
+      int address = ntohl(
+          reinterpret_cast<sockaddr_in*>(result->ai_addr)->sin_addr.s_addr);
 
       freeaddrinfo(result);
       return address;
@@ -119,4 +134,3 @@ Java_java_net_InetAddress_ipv4AddressForName(JNIEnv* e,
     return 0;
   }
 }
-
diff --git a/classpath/java-nio.cpp b/classpath/java-nio.cpp
index 065e8a45ff..2e2a86cb38 100644
--- a/classpath/java-nio.cpp
+++ b/classpath/java-nio.cpp
@@ -17,25 +17,25 @@
 #include "jni-util.h"
 
 #ifdef PLATFORM_WINDOWS
-#  include <winsock2.h>
-#  include <ws2tcpip.h>
-#  include <errno.h>
-#  ifdef _MSC_VER
-#    define snprintf sprintf_s
-#  else
-#    include <unistd.h>
-#  endif
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <errno.h>
+#ifdef _MSC_VER
+#define snprintf sprintf_s
 #else
-#  include <unistd.h>
-#  include <fcntl.h>
-#  include <errno.h>
-#  include <netdb.h>
-#  include <sys/select.h>
-#  include <arpa/inet.h>
-#  include <netinet/in.h>
-#  include <netinet/ip.h>
-#  include <netinet/tcp.h>
-#  include <sys/socket.h>
+#include <unistd.h>
+#endif
+#else
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <netdb.h>
+#include <sys/select.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/tcp.h>
+#include <sys/socket.h>
 #endif
 
 #define java_nio_channels_SelectionKey_OP_READ 1L
@@ -47,12 +47,14 @@
 typedef int socklen_t;
 #endif
 
-inline void* operator new(size_t, void* p) throw() { return p; }
+inline void* operator new(size_t, void* p) throw()
+{
+  return p;
+}
 
 namespace {
 
-inline jbyteArray
-charsToArray(JNIEnv* e, const char* s)
+inline jbyteArray charsToArray(JNIEnv* e, const char* s)
 {
   unsigned length = strlen(s);
   jbyteArray a = e->NewByteArray(length + 1);
@@ -60,8 +62,7 @@ charsToArray(JNIEnv* e, const char* s)
   return a;
 }
 
-inline void
-doClose(int socket)
+inline void doClose(int socket)
 {
 #ifdef PLATFORM_WINDOWS
   closesocket(socket);
@@ -70,8 +71,7 @@ doClose(int socket)
 #endif
 }
 
-inline jbyteArray
-errorString(JNIEnv* e, int n)
+inline jbyteArray errorString(JNIEnv* e, int n)
 {
 #ifdef _MSC_VER
   const unsigned size = 128;
@@ -83,8 +83,7 @@ errorString(JNIEnv* e, int n)
 #endif
 }
 
-inline jbyteArray
-socketErrorString(JNIEnv* e, int n)
+inline jbyteArray socketErrorString(JNIEnv* e, int n)
 {
 #ifdef PLATFORM_WINDOWS
   const unsigned size = 64;
@@ -96,8 +95,7 @@ socketErrorString(JNIEnv* e, int n)
 #endif
 }
 
-inline jbyteArray
-errorString(JNIEnv* e)
+inline jbyteArray errorString(JNIEnv* e)
 {
 #ifdef PLATFORM_WINDOWS
   const unsigned size = 64;
@@ -109,8 +107,7 @@ errorString(JNIEnv* e)
 #endif
 }
 
-void
-throwIOException(JNIEnv* e, const char* s)
+void throwIOException(JNIEnv* e, const char* s)
 {
   throwNew(e, "java/io/IOException", s);
 }
@@ -128,20 +125,17 @@ void throwIOException(JNIEnv* e, jbyteArray a)
   }
 }
 
-void
-throwIOException(JNIEnv* e)
+void throwIOException(JNIEnv* e)
 {
   throwIOException(e, errorString(e));
 }
 
-void
-throwSocketException(JNIEnv* e, const char* s)
+void throwSocketException(JNIEnv* e, const char* s)
 {
   throwNew(e, "java/net/SocketException", s);
 }
 
-void
-throwSocketException(JNIEnv* e, jbyteArray a)
+void throwSocketException(JNIEnv* e, jbyteArray a)
 {
   size_t length = e->GetArrayLength(a);
   uint8_t* buf = static_cast<uint8_t*>(allocate(e, length));
@@ -154,8 +148,7 @@ throwSocketException(JNIEnv* e, jbyteArray a)
   }
 }
 
-void
-throwSocketException(JNIEnv* e)
+void throwSocketException(JNIEnv* e)
 {
   throwSocketException(e, errorString(e));
 }
@@ -168,41 +161,36 @@ void init(sockaddr_in* address, jint host, jint port)
   address->sin_addr.s_addr = htonl(host);
 }
 
-inline bool
-einProgress(int error)
+inline bool einProgress(int error)
 {
 #ifdef PLATFORM_WINDOWS
-  return error == WSAEINPROGRESS
-    or error == WSAEWOULDBLOCK;
+  return error == WSAEINPROGRESS or error == WSAEWOULDBLOCK;
 #else
   return error == EINPROGRESS;
 #endif
 }
 
-inline bool
-einProgress()
+inline bool einProgress()
 {
 #ifdef PLATFORM_WINDOWS
   return WSAGetLastError() == WSAEINPROGRESS
-    or WSAGetLastError() == WSAEWOULDBLOCK;
+         or WSAGetLastError() == WSAEWOULDBLOCK;
 #else
   return errno == EINPROGRESS;
 #endif
 }
 
-inline bool
-eagain()
+inline bool eagain()
 {
 #ifdef PLATFORM_WINDOWS
   return WSAGetLastError() == WSAEINPROGRESS
-    or WSAGetLastError() == WSAEWOULDBLOCK;
+         or WSAGetLastError() == WSAEWOULDBLOCK;
 #else
   return errno == EAGAIN;
 #endif
 }
 
-bool
-setBlocking(JNIEnv* e, int d, bool blocking)
+bool setBlocking(JNIEnv* e, int d, bool blocking)
 {
 #ifdef PLATFORM_WINDOWS
   u_long a = (blocking ? 0 : 1);
@@ -212,9 +200,10 @@ setBlocking(JNIEnv* e, int d, bool blocking)
     return false;
   }
 #else
-  int r = fcntl(d, F_SETFL, (blocking
-                             ? (fcntl(d, F_GETFL) & (~O_NONBLOCK))
-                             : (fcntl(d, F_GETFL) | O_NONBLOCK)));
+  int r = fcntl(d,
+                F_SETFL,
+                (blocking ? (fcntl(d, F_GETFL) & (~O_NONBLOCK))
+                          : (fcntl(d, F_GETFL) | O_NONBLOCK)));
   if (r < 0) {
     throwIOException(e);
     return false;
@@ -223,12 +212,11 @@ setBlocking(JNIEnv* e, int d, bool blocking)
   return true;
 }
 
-bool
-setTcpNoDelay(JNIEnv* e, int d, bool on)
+bool setTcpNoDelay(JNIEnv* e, int d, bool on)
 {
   int flag = on;
-  int r = setsockopt
-    (d, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char*>(&flag), sizeof(int));
+  int r = setsockopt(
+      d, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char*>(&flag), sizeof(int));
   if (r < 0) {
     throwSocketException(e);
     return false;
@@ -236,12 +224,15 @@ setTcpNoDelay(JNIEnv* e, int d, bool on)
   return true;
 }
 
-void
-doBind(JNIEnv* e, int s, sockaddr_in* address)
+void doBind(JNIEnv* e, int s, sockaddr_in* address)
 {
-  { int opt = 1;
-    int r = ::setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
-                         reinterpret_cast<char*>(&opt), sizeof(int));
+  {
+    int opt = 1;
+    int r = ::setsockopt(s,
+                         SOL_SOCKET,
+                         SO_REUSEADDR,
+                         reinterpret_cast<char*>(&opt),
+                         sizeof(int));
     if (r != 0) {
       throwIOException(e);
       return;
@@ -249,9 +240,13 @@ doBind(JNIEnv* e, int s, sockaddr_in* address)
   }
 
 #ifdef SO_NOSIGPIPE
-  { int opt = 1;
-    int r = ::setsockopt(s, SOL_SOCKET, SO_NOSIGPIPE,
-                         reinterpret_cast<char*>(&opt), sizeof(int));
+  {
+    int opt = 1;
+    int r = ::setsockopt(s,
+                         SOL_SOCKET,
+                         SO_NOSIGPIPE,
+                         reinterpret_cast<char*>(&opt),
+                         sizeof(int));
     if (r != 0) {
       throwIOException(e);
       return;
@@ -259,8 +254,9 @@ doBind(JNIEnv* e, int s, sockaddr_in* address)
   }
 #endif
 
-  { int r = ::bind
-      (s, reinterpret_cast<sockaddr*>(address), sizeof(sockaddr_in));
+  {
+    int r
+        = ::bind(s, reinterpret_cast<sockaddr*>(address), sizeof(sockaddr_in));
     if (r != 0) {
       throwIOException(e);
       return;
@@ -268,8 +264,7 @@ doBind(JNIEnv* e, int s, sockaddr_in* address)
   }
 }
 
-void
-doListen(JNIEnv* e, int s)
+void doListen(JNIEnv* e, int s)
 {
   int r = ::listen(s, 100);
   if (r != 0) {
@@ -277,13 +272,12 @@ doListen(JNIEnv* e, int s)
   }
 }
 
-void
-doFinishConnect(JNIEnv* e, int socket)
+void doFinishConnect(JNIEnv* e, int socket)
 {
   int error;
   socklen_t size = sizeof(int);
-  int r = getsockopt(socket, SOL_SOCKET, SO_ERROR,
-                     reinterpret_cast<char*>(&error), &size);
+  int r = getsockopt(
+      socket, SOL_SOCKET, SO_ERROR, reinterpret_cast<char*>(&error), &size);
 
   if (r != 0 or size != sizeof(int)) {
     throwIOException(e);
@@ -292,11 +286,10 @@ doFinishConnect(JNIEnv* e, int socket)
   }
 }
 
-bool
-doConnect(JNIEnv* e, int s, sockaddr_in* address)
+bool doConnect(JNIEnv* e, int s, sockaddr_in* address)
 {
-  int r = ::connect(s, reinterpret_cast<sockaddr*>(address),
-                    sizeof(sockaddr_in));
+  int r
+      = ::connect(s, reinterpret_cast<sockaddr*>(address), sizeof(sockaddr_in));
   if (r == 0) {
     return true;
   } else if (not einProgress()) {
@@ -307,8 +300,7 @@ doConnect(JNIEnv* e, int s, sockaddr_in* address)
   }
 }
 
-int
-doAccept(JNIEnv* e, int s)
+int doAccept(JNIEnv* e, int s)
 {
   sockaddr address;
   socklen_t length = sizeof(address);
@@ -321,8 +313,7 @@ doAccept(JNIEnv* e, int s)
   return -1;
 }
 
-int
-doRead(int fd, void* buffer, size_t count)
+int doRead(int fd, void* buffer, size_t count)
 {
 #ifdef PLATFORM_WINDOWS
   return recv(fd, static_cast<char*>(buffer), count, 0);
@@ -331,16 +322,15 @@ doRead(int fd, void* buffer, size_t count)
 #endif
 }
 
-int
-doRecv(int fd, void* buffer, size_t count, int32_t* host, int32_t* port)
+int doRecv(int fd, void* buffer, size_t count, int32_t* host, int32_t* port)
 {
   sockaddr address;
   socklen_t length = sizeof(address);
-  int r = recvfrom
-    (fd, static_cast<char*>(buffer), count, 0, &address, &length);
-  
+  int r = recvfrom(fd, static_cast<char*>(buffer), count, 0, &address, &length);
+
   if (r > 0) {
-    sockaddr_in a; memcpy(&a, &address, length);
+    sockaddr_in a;
+    memcpy(&a, &address, length);
     *host = ntohl(a.sin_addr.s_addr);
     *port = ntohs(a.sin_port);
   } else {
@@ -351,8 +341,7 @@ doRecv(int fd, void* buffer, size_t count, int32_t* host, int32_t* port)
   return r;
 }
 
-int
-doWrite(int fd, const void* buffer, size_t count)
+int doWrite(int fd, const void* buffer, size_t count)
 {
 #ifdef PLATFORM_WINDOWS
   return send(fd, static_cast<const char*>(buffer), count, 0);
@@ -382,11 +371,12 @@ int makeSocket(JNIEnv* e, int type = SOCK_STREAM, int protocol = IPPROTO_TCP)
   return s;
 }
 
-} // namespace <anonymous>
-
+}  // namespace <anonymous>
 
 extern "C" JNIEXPORT jint JNICALL
-Java_java_nio_channels_ServerSocketChannel_natDoAccept(JNIEnv *e, jclass, jint socket)
+    Java_java_nio_channels_ServerSocketChannel_natDoAccept(JNIEnv* e,
+                                                           jclass,
+                                                           jint socket)
 {
   return ::doAccept(e, socket);
 }
@@ -432,29 +422,29 @@ extern "C" JNIEXPORT void JNICALL
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_nio_channels_SocketChannel_configureBlocking(JNIEnv *e,
-                                                       jclass,
-                                                       jint socket,
-                                                       jboolean blocking)
+    Java_java_nio_channels_SocketChannel_configureBlocking(JNIEnv* e,
+                                                           jclass,
+                                                           jint socket,
+                                                           jboolean blocking)
 {
   setBlocking(e, socket, blocking);
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_nio_channels_DatagramChannel_configureBlocking(JNIEnv* e,
-                                                         jclass c,
-                                                         jint socket,
-                                                         jboolean blocking)
+    Java_java_nio_channels_DatagramChannel_configureBlocking(JNIEnv* e,
+                                                             jclass c,
+                                                             jint socket,
+                                                             jboolean blocking)
 {
-  return Java_java_nio_channels_SocketChannel_configureBlocking
-    (e, c, socket, blocking);
+  return Java_java_nio_channels_SocketChannel_configureBlocking(
+      e, c, socket, blocking);
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_nio_channels_SocketChannel_natSetTcpNoDelay(JNIEnv *e,
-                                                      jclass,
-                                                      jint socket,
-                                                      jboolean on)
+    Java_java_nio_channels_SocketChannel_natSetTcpNoDelay(JNIEnv* e,
+                                                          jclass,
+                                                          jint socket,
+                                                          jboolean on)
 {
   setTcpNoDelay(e, socket, on);
 }
@@ -498,21 +488,21 @@ extern "C" JNIEXPORT jboolean JNICALL
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_nio_channels_SocketChannel_natFinishConnect(JNIEnv *e,
-                                                      jclass,
-                                                      jint socket)
+    Java_java_nio_channels_SocketChannel_natFinishConnect(JNIEnv* e,
+                                                          jclass,
+                                                          jint socket)
 {
   doFinishConnect(e, socket);
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_java_nio_channels_SocketChannel_natRead(JNIEnv *e,
-					     jclass,
-					     jint socket,
-					     jbyteArray buffer,
-					     jint offset,
-					     jint length,
-                                             jboolean blocking)
+    Java_java_nio_channels_SocketChannel_natRead(JNIEnv* e,
+                                                 jclass,
+                                                 jint socket,
+                                                 jbyteArray buffer,
+                                                 jint offset,
+                                                 jint length,
+                                                 jboolean blocking)
 {
   int r;
   if (blocking) {
@@ -520,8 +510,7 @@ Java_java_nio_channels_SocketChannel_natRead(JNIEnv *e,
     if (buf) {
       r = ::doRead(socket, buf, length);
       if (r > 0) {
-        e->SetByteArrayRegion
-          (buffer, offset, r, reinterpret_cast<jbyte*>(buf));
+        e->SetByteArrayRegion(buffer, offset, r, reinterpret_cast<jbyte*>(buf));
       }
       free(buf);
     } else {
@@ -529,8 +518,8 @@ Java_java_nio_channels_SocketChannel_natRead(JNIEnv *e,
     }
   } else {
     jboolean isCopy;
-    uint8_t* buf = static_cast<uint8_t*>
-      (e->GetPrimitiveArrayCritical(buffer, &isCopy));
+    uint8_t* buf
+        = static_cast<uint8_t*>(e->GetPrimitiveArrayCritical(buffer, &isCopy));
 
     r = ::doRead(socket, buf + offset, length);
 
@@ -550,14 +539,14 @@ Java_java_nio_channels_SocketChannel_natRead(JNIEnv *e,
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_java_nio_channels_DatagramChannel_receive(JNIEnv* e,
-                                               jclass,
-                                               jint socket,
-                                               jbyteArray buffer,
-                                               jint offset,
-                                               jint length,
-                                               jboolean blocking,
-                                               jintArray address)
+    Java_java_nio_channels_DatagramChannel_receive(JNIEnv* e,
+                                                   jclass,
+                                                   jint socket,
+                                                   jbyteArray buffer,
+                                                   jint offset,
+                                                   jint length,
+                                                   jboolean blocking,
+                                                   jintArray address)
 {
   int r;
   int32_t host;
@@ -567,8 +556,7 @@ Java_java_nio_channels_DatagramChannel_receive(JNIEnv* e,
     if (buf) {
       r = ::doRecv(socket, buf, length, &host, &port);
       if (r > 0) {
-        e->SetByteArrayRegion
-          (buffer, offset, r, reinterpret_cast<jbyte*>(buf));
+        e->SetByteArrayRegion(buffer, offset, r, reinterpret_cast<jbyte*>(buf));
       }
       free(buf);
     } else {
@@ -576,8 +564,8 @@ Java_java_nio_channels_DatagramChannel_receive(JNIEnv* e,
     }
   } else {
     jboolean isCopy;
-    uint8_t* buf = static_cast<uint8_t*>
-      (e->GetPrimitiveArrayCritical(buffer, &isCopy));
+    uint8_t* buf
+        = static_cast<uint8_t*>(e->GetPrimitiveArrayCritical(buffer, &isCopy));
 
     r = ::doRecv(socket, buf + offset, length, &host, &port);
 
@@ -593,28 +581,30 @@ Java_java_nio_channels_DatagramChannel_receive(JNIEnv* e,
   } else if (r == 0) {
     return -1;
   } else {
-    jint jhost = host; e->SetIntArrayRegion(address, 0, 1, &jhost);
-    jint jport = port; e->SetIntArrayRegion(address, 1, 1, &jport);
+    jint jhost = host;
+    e->SetIntArrayRegion(address, 0, 1, &jhost);
+    jint jport = port;
+    e->SetIntArrayRegion(address, 1, 1, &jport);
   }
 
   return r;
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_java_nio_channels_SocketChannel_natWrite(JNIEnv *e,
-					      jclass,
-					      jint socket,
-					      jbyteArray buffer,
-					      jint offset,
-					      jint length,
-                                              jboolean blocking)
+    Java_java_nio_channels_SocketChannel_natWrite(JNIEnv* e,
+                                                  jclass,
+                                                  jint socket,
+                                                  jbyteArray buffer,
+                                                  jint offset,
+                                                  jint length,
+                                                  jboolean blocking)
 {
   int r;
   if (blocking) {
     uint8_t* buf = static_cast<uint8_t*>(allocate(e, length));
     if (buf) {
-      e->GetByteArrayRegion
-        (buffer, offset, length, reinterpret_cast<jbyte*>(buf));
+      e->GetByteArrayRegion(
+          buffer, offset, length, reinterpret_cast<jbyte*>(buf));
       r = ::doWrite(socket, buf, length);
       free(buf);
     } else {
@@ -622,8 +612,8 @@ Java_java_nio_channels_SocketChannel_natWrite(JNIEnv *e,
     }
   } else {
     jboolean isCopy;
-    uint8_t* buf = static_cast<uint8_t*>
-      (e->GetPrimitiveArrayCritical(buffer, &isCopy));
+    uint8_t* buf
+        = static_cast<uint8_t*>(e->GetPrimitiveArrayCritical(buffer, &isCopy));
 
     r = ::doWrite(socket, buf + offset, length);
 
@@ -641,16 +631,16 @@ Java_java_nio_channels_SocketChannel_natWrite(JNIEnv *e,
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_java_nio_channels_DatagramChannel_write(JNIEnv* e,
-                                             jclass c,
-                                             jint socket,
-                                             jbyteArray buffer,
-                                             jint offset,
-                                             jint length,
-                                             jboolean blocking)
+    Java_java_nio_channels_DatagramChannel_write(JNIEnv* e,
+                                                 jclass c,
+                                                 jint socket,
+                                                 jbyteArray buffer,
+                                                 jint offset,
+                                                 jint length,
+                                                 jboolean blocking)
 {
-  return Java_java_nio_channels_SocketChannel_natWrite
-    (e, c, socket, buffer, offset, length, blocking);
+  return Java_java_nio_channels_SocketChannel_natWrite(
+      e, c, socket, buffer, offset, length, blocking);
 }
 
 extern "C" JNIEXPORT jint JNICALL
@@ -699,14 +689,14 @@ extern "C" JNIEXPORT jint JNICALL
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_nio_channels_SocketChannel_natThrowWriteError(JNIEnv *e,
-							jclass,
-							jint socket)
+    Java_java_nio_channels_SocketChannel_natThrowWriteError(JNIEnv* e,
+                                                            jclass,
+                                                            jint socket)
 {
   int error;
   socklen_t size = sizeof(int);
-  int r = getsockopt(socket, SOL_SOCKET, SO_ERROR,
-		     reinterpret_cast<char*>(&error), &size);
+  int r = getsockopt(
+      socket, SOL_SOCKET, SO_ERROR, reinterpret_cast<char*>(&error), &size);
   if (r != 0 or size != sizeof(int)) {
     throwIOException(e);
   } else if (error != 0) {
@@ -715,17 +705,15 @@ Java_java_nio_channels_SocketChannel_natThrowWriteError(JNIEnv *e,
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_nio_channels_SocketChannel_natCloseSocket(JNIEnv *,
-						    jclass,
-						    jint socket)
+    Java_java_nio_channels_SocketChannel_natCloseSocket(JNIEnv*,
+                                                        jclass,
+                                                        jint socket)
 {
   doClose(socket);
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_nio_channels_DatagramChannel_close(JNIEnv *,
-                                             jclass,
-                                             jint socket)
+    Java_java_nio_channels_DatagramChannel_close(JNIEnv*, jclass, jint socket)
 {
   doClose(socket);
 }
@@ -739,69 +727,85 @@ class Pipe {
   // pipe descriptors or others.  Thus, to implement
   // Selector.wakeup(), we make a socket connection via the loopback
   // interface and use it as a pipe.
-  Pipe(JNIEnv* e): connected_(false), listener_(-1), reader_(-1), writer_(-1) {
+  Pipe(JNIEnv* e) : connected_(false), listener_(-1), reader_(-1), writer_(-1)
+  {
     sockaddr_in address;
     address.sin_family = AF_INET;
     address.sin_port = 0;
-    address.sin_addr.s_addr = inet_addr("127.0.0.1"); //INADDR_LOOPBACK;
+    address.sin_addr.s_addr = inet_addr("127.0.0.1");  // INADDR_LOOPBACK;
 
     listener_ = makeSocket(e);
-    if (e->ExceptionCheck()) return;
+    if (e->ExceptionCheck())
+      return;
 
     setBlocking(e, listener_, false);
 
     ::doBind(e, listener_, &address);
-    if (e->ExceptionCheck()) return;
+    if (e->ExceptionCheck())
+      return;
 
     ::doListen(e, listener_);
-    if (e->ExceptionCheck()) return;
+    if (e->ExceptionCheck())
+      return;
 
     socklen_t length = sizeof(sockaddr_in);
-    int r = getsockname(listener_, reinterpret_cast<sockaddr*>(&address),
-                        &length);
+    int r = getsockname(
+        listener_, reinterpret_cast<sockaddr*>(&address), &length);
     if (r) {
       throwIOException(e);
       return;
     }
 
     writer_ = makeSocket(e);
-    if (e->ExceptionCheck()) return;
+    if (e->ExceptionCheck())
+      return;
 
     setBlocking(e, writer_, true);
     connected_ = ::doConnect(e, writer_, &address);
   }
 
-  void dispose() {
-    if (listener_ >= 0) ::doClose(listener_);
-    if (reader_ >= 0) ::doClose(reader_);
-    if (writer_ >= 0) ::doClose(writer_);
+  void dispose()
+  {
+    if (listener_ >= 0)
+      ::doClose(listener_);
+    if (reader_ >= 0)
+      ::doClose(reader_);
+    if (writer_ >= 0)
+      ::doClose(writer_);
   }
 
-  bool connected() {
+  bool connected()
+  {
     return connected_;
   }
 
-  void setConnected(bool v) {
+  void setConnected(bool v)
+  {
     connected_ = v;
   }
 
-  int listener() {
+  int listener()
+  {
     return listener_;
   }
 
-  void setListener(int v) {
+  void setListener(int v)
+  {
     listener_ = v;
   }
 
-  int reader() {
+  int reader()
+  {
     return reader_;
   }
 
-  void setReader(int v) {
+  void setReader(int v)
+  {
     reader_ = v;
   }
 
-  int writer() {
+  int writer()
+  {
     return writer_;
   }
 
@@ -811,7 +815,8 @@ class Pipe {
   int reader_;
   int writer_;
 #else
-  Pipe(JNIEnv* e) {
+  Pipe(JNIEnv* e)
+  {
     if (::pipe(pipe) != 0) {
       throwIOException(e);
       return;
@@ -824,21 +829,25 @@ class Pipe {
     open_ = true;
   }
 
-  void dispose() {
+  void dispose()
+  {
     ::doClose(pipe[0]);
     ::doClose(pipe[1]);
     open_ = false;
   }
 
-  bool connected() {
+  bool connected()
+  {
     return open_;
   }
 
-  int reader() {
+  int reader()
+  {
     return pipe[0];
   }
 
-  int writer() {
+  int writer()
+  {
     return pipe[1];
   }
 
@@ -853,18 +862,21 @@ struct SelectorState {
   fd_set write;
   fd_set except;
   Pipe control;
-  SelectorState(JNIEnv* e) : control(e) { }
+  SelectorState(JNIEnv* e) : control(e)
+  {
+  }
 };
 
-} // namespace
+}  // namespace
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_java_nio_channels_SocketSelector_natInit(JNIEnv* e, jclass)
+    Java_java_nio_channels_SocketSelector_natInit(JNIEnv* e, jclass)
 {
-  void *mem = malloc(sizeof(SelectorState));
+  void* mem = malloc(sizeof(SelectorState));
   if (mem) {
-    SelectorState *s = new (mem) SelectorState(e);
-    if (e->ExceptionCheck()) return 0;
+    SelectorState* s = new (mem) SelectorState(e);
+    if (e->ExceptionCheck())
+      return 0;
 
     if (s) {
       FD_ZERO(&(s->read));
@@ -878,7 +890,9 @@ Java_java_nio_channels_SocketSelector_natInit(JNIEnv* e, jclass)
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_nio_channels_SocketSelector_natWakeup(JNIEnv *e, jclass, jlong state)
+    Java_java_nio_channels_SocketSelector_natWakeup(JNIEnv* e,
+                                                    jclass,
+                                                    jlong state)
 {
   SelectorState* s = reinterpret_cast<SelectorState*>(state);
   if (s->control.connected()) {
@@ -891,7 +905,7 @@ Java_java_nio_channels_SocketSelector_natWakeup(JNIEnv *e, jclass, jlong state)
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_nio_channels_SocketSelector_natClose(JNIEnv *, jclass, jlong state)
+    Java_java_nio_channels_SocketSelector_natClose(JNIEnv*, jclass, jlong state)
 {
   SelectorState* s = reinterpret_cast<SelectorState*>(state);
   s->control.dispose();
@@ -899,9 +913,10 @@ Java_java_nio_channels_SocketSelector_natClose(JNIEnv *, jclass, jlong state)
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_nio_channels_SocketSelector_natSelectClearAll(JNIEnv *, jclass,
-							jint socket,
-							jlong state)
+    Java_java_nio_channels_SocketSelector_natSelectClearAll(JNIEnv*,
+                                                            jclass,
+                                                            jint socket,
+                                                            jlong state)
 {
   SelectorState* s = reinterpret_cast<SelectorState*>(state);
   FD_CLR(static_cast<unsigned>(socket), &(s->read));
@@ -910,27 +925,30 @@ Java_java_nio_channels_SocketSelector_natSelectClearAll(JNIEnv *, jclass,
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_java_nio_channels_SocketSelector_natSelectUpdateInterestSet(JNIEnv *,
-								 jclass,
-								 jint socket,
-								 jint interest,
-								 jlong state,
-								 jint max)
+    Java_java_nio_channels_SocketSelector_natSelectUpdateInterestSet(
+        JNIEnv*,
+        jclass,
+        jint socket,
+        jint interest,
+        jlong state,
+        jint max)
 {
   SelectorState* s = reinterpret_cast<SelectorState*>(state);
-  if (interest & (java_nio_channels_SelectionKey_OP_READ |
-		  java_nio_channels_SelectionKey_OP_ACCEPT)) {
+  if (interest & (java_nio_channels_SelectionKey_OP_READ
+                  | java_nio_channels_SelectionKey_OP_ACCEPT)) {
     FD_SET(static_cast<unsigned>(socket), &(s->read));
-    if (max < socket) max = socket;
+    if (max < socket)
+      max = socket;
   } else {
     FD_CLR(static_cast<unsigned>(socket), &(s->read));
   }
-  
-  if (interest & (java_nio_channels_SelectionKey_OP_WRITE |
-		  java_nio_channels_SelectionKey_OP_CONNECT)) {
+
+  if (interest & (java_nio_channels_SelectionKey_OP_WRITE
+                  | java_nio_channels_SelectionKey_OP_CONNECT)) {
     FD_SET(static_cast<unsigned>(socket), &(s->write));
     FD_SET(static_cast<unsigned>(socket), &(s->except));
-    if (max < socket) max = socket;
+    if (max < socket)
+      max = socket;
   } else {
     FD_CLR(static_cast<unsigned>(socket), &(s->write));
   }
@@ -938,30 +956,34 @@ Java_java_nio_channels_SocketSelector_natSelectUpdateInterestSet(JNIEnv *,
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_java_nio_channels_SocketSelector_natDoSocketSelect(JNIEnv *e, jclass,
-							jlong state,
-							jint max,
-							jlong interval)
+    Java_java_nio_channels_SocketSelector_natDoSocketSelect(JNIEnv* e,
+                                                            jclass,
+                                                            jlong state,
+                                                            jint max,
+                                                            jlong interval)
 {
   SelectorState* s = reinterpret_cast<SelectorState*>(state);
   if (s->control.reader() >= 0) {
     int socket = s->control.reader();
     FD_SET(static_cast<unsigned>(socket), &(s->read));
-    if (max < socket) max = socket;
+    if (max < socket)
+      max = socket;
   }
 
 #ifdef PLATFORM_WINDOWS
   if (s->control.listener() >= 0) {
     int socket = s->control.listener();
     FD_SET(static_cast<unsigned>(socket), &(s->read));
-    if (max < socket) max = socket;
+    if (max < socket)
+      max = socket;
   }
 
   if (not s->control.connected()) {
     int socket = s->control.writer();
     FD_SET(static_cast<unsigned>(socket), &(s->write));
     FD_SET(static_cast<unsigned>(socket), &(s->except));
-    if (max < socket) max = socket;
+    if (max < socket)
+      max = socket;
   }
 #endif
 
@@ -986,17 +1008,16 @@ Java_java_nio_channels_SocketSelector_natDoSocketSelect(JNIEnv *e, jclass,
   }
 
 #ifdef PLATFORM_WINDOWS
-  if (FD_ISSET(s->control.writer(), &(s->write)) or
-      FD_ISSET(s->control.writer(), &(s->except)))
-  {
+  if (FD_ISSET(s->control.writer(), &(s->write))
+      or FD_ISSET(s->control.writer(), &(s->except))) {
     int socket = s->control.writer();
     FD_CLR(static_cast<unsigned>(socket), &(s->write));
     FD_CLR(static_cast<unsigned>(socket), &(s->except));
 
     int error;
     socklen_t size = sizeof(int);
-    int r = getsockopt(socket, SOL_SOCKET, SO_ERROR,
-                       reinterpret_cast<char*>(&error), &size);
+    int r = getsockopt(
+        socket, SOL_SOCKET, SO_ERROR, reinterpret_cast<char*>(&error), &size);
     if (r != 0 or size != sizeof(int)) {
       throwIOException(e);
     } else if (error != 0) {
@@ -1005,9 +1026,8 @@ Java_java_nio_channels_SocketSelector_natDoSocketSelect(JNIEnv *e, jclass,
     s->control.setConnected(true);
   }
 
-  if (s->control.listener() >= 0 and
-      FD_ISSET(s->control.listener(), &(s->read)))
-  {
+  if (s->control.listener() >= 0
+      and FD_ISSET(s->control.listener(), &(s->read))) {
     FD_CLR(static_cast<unsigned>(s->control.listener()), &(s->read));
 
     s->control.setReader(::doAccept(e, s->control.listener()));
@@ -1015,9 +1035,7 @@ Java_java_nio_channels_SocketSelector_natDoSocketSelect(JNIEnv *e, jclass,
   }
 #endif
 
-  if (s->control.reader() >= 0 and
-      FD_ISSET(s->control.reader(), &(s->read)))
-  {
+  if (s->control.reader() >= 0 and FD_ISSET(s->control.reader(), &(s->read))) {
     FD_CLR(static_cast<unsigned>(s->control.reader()), &(s->read));
 
     char c;
@@ -1034,24 +1052,25 @@ Java_java_nio_channels_SocketSelector_natDoSocketSelect(JNIEnv *e, jclass,
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_java_nio_channels_SocketSelector_natUpdateReadySet(JNIEnv *, jclass,
-							jint socket,
-							jint interest,
-							jlong state)
+    Java_java_nio_channels_SocketSelector_natUpdateReadySet(JNIEnv*,
+                                                            jclass,
+                                                            jint socket,
+                                                            jint interest,
+                                                            jlong state)
 {
   SelectorState* s = reinterpret_cast<SelectorState*>(state);
   jint ready = 0;
-        
+
   if (FD_ISSET(socket, &(s->read))) {
     if (interest & java_nio_channels_SelectionKey_OP_READ) {
       ready |= java_nio_channels_SelectionKey_OP_READ;
     }
-    
+
     if (interest & java_nio_channels_SelectionKey_OP_ACCEPT) {
       ready |= java_nio_channels_SelectionKey_OP_ACCEPT;
     }
   }
-  
+
   if (FD_ISSET(socket, &(s->write)) or FD_ISSET(socket, &(s->except))) {
     if (interest & java_nio_channels_SelectionKey_OP_WRITE) {
       ready |= java_nio_channels_SelectionKey_OP_WRITE;
@@ -1059,15 +1078,14 @@ Java_java_nio_channels_SocketSelector_natUpdateReadySet(JNIEnv *, jclass,
 
     if (interest & java_nio_channels_SelectionKey_OP_CONNECT) {
       ready |= java_nio_channels_SelectionKey_OP_CONNECT;
-    }    
+    }
   }
 
   return ready;
 }
 
-
 extern "C" JNIEXPORT jboolean JNICALL
-Java_java_nio_ByteOrder_isNativeBigEndian(JNIEnv *, jclass)
+    Java_java_nio_ByteOrder_isNativeBigEndian(JNIEnv*, jclass)
 {
   union {
     uint32_t i;
diff --git a/classpath/java-util-zip.cpp b/classpath/java-util-zip.cpp
index e6f20a77f2..13a934d1af 100644
--- a/classpath/java-util-zip.cpp
+++ b/classpath/java-util-zip.cpp
@@ -16,17 +16,16 @@
 #include "jni-util.h"
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_java_util_zip_Inflater_make
-(JNIEnv* e, jclass, jboolean nowrap)
+    Java_java_util_zip_Inflater_make(JNIEnv* e, jclass, jboolean nowrap)
 {
   z_stream* s = static_cast<z_stream*>(malloc(sizeof(z_stream)));
   if (s == 0) {
     throwNew(e, "java/lang/OutOfMemoryError", 0);
-    return 0;    
+    return 0;
   }
 
   memset(s, 0, sizeof(z_stream));
-  
+
   int r = inflateInit2(s, (nowrap ? -15 : 15));
   if (r != Z_OK) {
     free(s);
@@ -38,7 +37,7 @@ Java_java_util_zip_Inflater_make
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_util_zip_Inflater_dispose(JNIEnv*, jclass, jlong peer)
+    Java_java_util_zip_Inflater_dispose(JNIEnv*, jclass, jlong peer)
 {
   z_stream* s = reinterpret_cast<z_stream*>(peer);
   inflateEnd(s);
@@ -46,39 +45,43 @@ Java_java_util_zip_Inflater_dispose(JNIEnv*, jclass, jlong peer)
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_util_zip_Inflater_inflate
-(JNIEnv* e, jclass, jlong peer,
- jbyteArray input, jint inputOffset, jint inputLength,
- jbyteArray output, jint outputOffset, jint outputLength,
- jintArray results)
+    Java_java_util_zip_Inflater_inflate(JNIEnv* e,
+                                        jclass,
+                                        jlong peer,
+                                        jbyteArray input,
+                                        jint inputOffset,
+                                        jint inputLength,
+                                        jbyteArray output,
+                                        jint outputOffset,
+                                        jint outputLength,
+                                        jintArray results)
 {
   z_stream* s = reinterpret_cast<z_stream*>(peer);
 
   jbyte* in = static_cast<jbyte*>(malloc(inputLength));
   if (in == 0) {
     throwNew(e, "java/lang/OutOfMemoryError", 0);
-    return;    
+    return;
   }
 
   jbyte* out = static_cast<jbyte*>(malloc(outputLength));
   if (out == 0) {
     free(in);
     throwNew(e, "java/lang/OutOfMemoryError", 0);
-    return;    
+    return;
   }
 
   e->GetByteArrayRegion(input, inputOffset, inputLength, in);
-  
+
   s->next_in = reinterpret_cast<Bytef*>(in);
   s->avail_in = inputLength;
   s->next_out = reinterpret_cast<Bytef*>(out);
   s->avail_out = outputLength;
 
   int r = inflate(s, Z_SYNC_FLUSH);
-  jint resultArray[3]
-    = { r,
-        static_cast<jint>(inputLength - s->avail_in),
-        static_cast<jint>(outputLength - s->avail_out) };
+  jint resultArray[3] = {r,
+                         static_cast<jint>(inputLength - s->avail_in),
+                         static_cast<jint>(outputLength - s->avail_out)};
 
   free(in);
 
@@ -89,17 +92,19 @@ Java_java_util_zip_Inflater_inflate
 }
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_java_util_zip_Deflater_make
-(JNIEnv* e, jclass, jboolean nowrap, jint level)
+    Java_java_util_zip_Deflater_make(JNIEnv* e,
+                                     jclass,
+                                     jboolean nowrap,
+                                     jint level)
 {
   z_stream* s = static_cast<z_stream*>(malloc(sizeof(z_stream)));
   if (s == 0) {
     throwNew(e, "java/lang/OutOfMemoryError", 0);
-    return 0;    
+    return 0;
   }
 
   memset(s, 0, sizeof(z_stream));
-  
+
   int r = deflateInit2(s, level, (nowrap ? -15 : 15));
   if (r != Z_OK) {
     free(s);
@@ -111,7 +116,7 @@ Java_java_util_zip_Deflater_make
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_util_zip_Deflater_dispose(JNIEnv*, jclass, jlong peer)
+    Java_java_util_zip_Deflater_dispose(JNIEnv*, jclass, jlong peer)
 {
   z_stream* s = reinterpret_cast<z_stream*>(peer);
   deflateEnd(s);
@@ -119,39 +124,44 @@ Java_java_util_zip_Deflater_dispose(JNIEnv*, jclass, jlong peer)
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_java_util_zip_Deflater_deflate
-(JNIEnv* e, jclass, jlong peer, 
- jbyteArray input, jint inputOffset, jint inputLength,
- jbyteArray output, jint outputOffset, jint outputLength,
- jboolean finish, jintArray results)
+    Java_java_util_zip_Deflater_deflate(JNIEnv* e,
+                                        jclass,
+                                        jlong peer,
+                                        jbyteArray input,
+                                        jint inputOffset,
+                                        jint inputLength,
+                                        jbyteArray output,
+                                        jint outputOffset,
+                                        jint outputLength,
+                                        jboolean finish,
+                                        jintArray results)
 {
   z_stream* s = reinterpret_cast<z_stream*>(peer);
 
   jbyte* in = static_cast<jbyte*>(malloc(inputLength));
   if (in == 0) {
     throwNew(e, "java/lang/OutOfMemoryError", 0);
-    return;    
+    return;
   }
 
   jbyte* out = static_cast<jbyte*>(malloc(outputLength));
   if (out == 0) {
     free(in);
     throwNew(e, "java/lang/OutOfMemoryError", 0);
-    return;    
+    return;
   }
 
   e->GetByteArrayRegion(input, inputOffset, inputLength, in);
-  
+
   s->next_in = reinterpret_cast<Bytef*>(in);
   s->avail_in = inputLength;
   s->next_out = reinterpret_cast<Bytef*>(out);
   s->avail_out = outputLength;
 
   int r = deflate(s, finish ? Z_FINISH : Z_NO_FLUSH);
-  jint resultArray[3]
-    = { r,
-        static_cast<jint>(inputLength - s->avail_in),
-        static_cast<jint>(outputLength - s->avail_out) };
+  jint resultArray[3] = {r,
+                         static_cast<jint>(inputLength - s->avail_in),
+                         static_cast<jint>(outputLength - s->avail_out)};
 
   free(in);
 
diff --git a/classpath/java-util.cpp b/classpath/java-util.cpp
index 270109f0d8..50a7f8778a 100644
--- a/classpath/java-util.cpp
+++ b/classpath/java-util.cpp
@@ -16,8 +16,7 @@ namespace {
 
 #if (!defined PLATFORM_WINDOWS) || (defined _MSC_VER)
 
-void
-removeNewline(char* s)
+void removeNewline(char* s)
 {
   for (; s; ++s) {
     if (*s == '\n') {
@@ -29,10 +28,10 @@ removeNewline(char* s)
 
 #endif
 
-} // namespace
+}  // namespace
 
 extern "C" JNIEXPORT jstring JNICALL
-Java_java_util_Date_toString(JNIEnv* e, jclass c UNUSED, jlong when)
+    Java_java_util_Date_toString(JNIEnv* e, jclass c UNUSED, jlong when)
 {
   const unsigned BufferSize UNUSED = 27;
 
@@ -40,13 +39,13 @@ Java_java_util_Date_toString(JNIEnv* e, jclass c UNUSED, jlong when)
 
 #ifdef PLATFORM_WINDOWS
   e->MonitorEnter(c);
-#  ifdef _MSC_VER
+#ifdef _MSC_VER
   char buffer[BufferSize];
   ctime_s(buffer, BufferSize, &time);
   removeNewline(buffer);
-#  else
+#else
   char* buffer = ctime(&time);
-#  endif
+#endif
   jstring r = e->NewStringUTF(buffer);
   e->MonitorExit(c);
   return r;
diff --git a/classpath/jni-util.h b/classpath/jni-util.h
index 951aa43fc0..d04c5de64a 100644
--- a/classpath/jni-util.h
+++ b/classpath/jni-util.h
@@ -20,19 +20,18 @@
 #undef JNIEXPORT
 
 #if (defined __MINGW32__) || (defined _MSC_VER)
-#  define PLATFORM_WINDOWS
-#  define PATH_SEPARATOR ';'
-#  define JNIEXPORT __declspec(dllexport)
-#else // not (defined __MINGW32__) || (defined _MSC_VER)
-#  define PLATFORM_POSIX
-#  define PATH_SEPARATOR ':'
-#  define JNIEXPORT __attribute__ ((visibility("default"))) \
-  __attribute__ ((used))
-#endif // not (defined __MINGW32__) || (defined _MSC_VER)
+#define PLATFORM_WINDOWS
+#define PATH_SEPARATOR ';'
+#define JNIEXPORT __declspec(dllexport)
+#else  // not (defined __MINGW32__) || (defined _MSC_VER)
+#define PLATFORM_POSIX
+#define PATH_SEPARATOR ':'
+#define JNIEXPORT __attribute__((visibility("default"))) __attribute__((used))
+#endif  // not (defined __MINGW32__) || (defined _MSC_VER)
 
 #ifdef _MSC_VER
 
-#  define UNUSED
+#define UNUSED
 
 typedef char int8_t;
 typedef unsigned char uint8_t;
@@ -43,38 +42,37 @@ typedef unsigned int uint32_t;
 typedef __int64 int64_t;
 typedef unsigned __int64 uint64_t;
 
-#  define INT32_MAX 2147483647
+#define INT32_MAX 2147483647
 
-#  define not !
-#  define or ||
-#  define and &&
-#  define xor ^
+#define not!
+#define or ||
+#define and &&
+#define xor ^
 
-#  ifdef _M_IX86
-#    define ARCH_x86_32
-#  elif defined _M_X64
-#    define ARCH_x86_64
-#  endif
+#ifdef _M_IX86
+#define ARCH_x86_32
+#elif defined _M_X64
+#define ARCH_x86_64
+#endif
 
-#else // not _MSC_VER
+#else  // not _MSC_VER
 
-#  define UNUSED __attribute__((unused))
+#define UNUSED __attribute__((unused))
 
-#  include "stdint.h"
-#  include "errno.h"
+#include "stdint.h"
+#include "errno.h"
 
-#  ifdef __i386__
-#    define ARCH_x86_32
-#  elif defined __x86_64__
-#    define ARCH_x86_64
-#  elif defined __arm__
-#    define ARCH_arm
-#  endif
+#ifdef __i386__
+#define ARCH_x86_32
+#elif defined __x86_64__
+#define ARCH_x86_64
+#elif defined __arm__
+#define ARCH_arm
+#endif
 
-#endif // not _MSC_VER
+#endif  // not _MSC_VER
 
-inline void
-throwNew(JNIEnv* e, const char* class_, const char* message, ...)
+inline void throwNew(JNIEnv* e, const char* class_, const char* message, ...)
 {
   jclass c = e->FindClass(class_);
   if (c) {
@@ -90,7 +88,7 @@ throwNew(JNIEnv* e, const char* class_, const char* message, ...)
       vsnprintf(buffer, BufferSize - 1, message, list);
 #endif
       va_end(list);
-      
+
       e->ThrowNew(c, buffer);
     } else {
       e->ThrowNew(c, 0);
@@ -99,8 +97,7 @@ throwNew(JNIEnv* e, const char* class_, const char* message, ...)
   }
 }
 
-inline void
-throwNewErrno(JNIEnv* e, const char* class_)
+inline void throwNewErrno(JNIEnv* e, const char* class_)
 {
 #ifdef _MSC_VER
   const unsigned size = 128;
@@ -112,8 +109,7 @@ throwNewErrno(JNIEnv* e, const char* class_)
 #endif
 }
 
-inline void*
-allocate(JNIEnv* e, unsigned size)
+inline void* allocate(JNIEnv* e, unsigned size)
 {
   void* p = malloc(size);
   if (p == 0) {
@@ -122,4 +118,4 @@ allocate(JNIEnv* e, unsigned size)
   return p;
 }
 
-#endif//JNI_UTIL
+#endif  // JNI_UTIL
diff --git a/classpath/sockets.cpp b/classpath/sockets.cpp
index b66b6de016..3a4b6fe8e5 100644
--- a/classpath/sockets.cpp
+++ b/classpath/sockets.cpp
@@ -19,166 +19,183 @@ namespace avian {
 namespace classpath {
 namespace sockets {
 
-int last_socket_error() {
+int last_socket_error()
+{
 #ifdef PLATFORM_WINDOWS
-		int error = WSAGetLastError();
+  int error = WSAGetLastError();
 #else
-		int error = errno;
+  int error = errno;
 #endif
-		return error;
+  return error;
 }
 
-
-void init(JNIEnv* ONLY_ON_WINDOWS(e)) {
+void init(JNIEnv* ONLY_ON_WINDOWS(e))
+{
 #ifdef PLATFORM_WINDOWS
   static bool wsaInitialized = false;
   if (not wsaInitialized) {
-	WSADATA data;
-	int r = WSAStartup(MAKEWORD(2, 2), &data);
-	if (r or LOBYTE(data.wVersion) != 2 or HIBYTE(data.wVersion) != 2) {
-	  throwNew(e, "java/io/IOException", "WSAStartup failed");
-	} else {
-	  wsaInitialized = true;
-	}
+    WSADATA data;
+    int r = WSAStartup(MAKEWORD(2, 2), &data);
+    if (r or LOBYTE(data.wVersion) != 2 or HIBYTE(data.wVersion) != 2) {
+      throwNew(e, "java/io/IOException", "WSAStartup failed");
+    } else {
+      wsaInitialized = true;
+    }
   }
 #endif
 }
 
-SOCKET create(JNIEnv* e) {
-	SOCKET sock;
-	if (INVALID_SOCKET == (sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP))) {
-		char buf[255];
-		sprintf(buf, "Can't create a socket. System error: %d", last_socket_error());
-		throwNew(e, "java/io/IOException", buf);
-		return 0;	// This doesn't matter cause we have risen an exception
-	}
-	return sock;
+SOCKET create(JNIEnv* e)
+{
+  SOCKET sock;
+  if (INVALID_SOCKET == (sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP))) {
+    char buf[255];
+    sprintf(
+        buf, "Can't create a socket. System error: %d", last_socket_error());
+    throwNew(e, "java/io/IOException", buf);
+    return 0;  // This doesn't matter cause we have risen an exception
+  }
+  return sock;
 }
 
-void connect(JNIEnv* e, SOCKET sock, long addr, short port) {
-	sockaddr_in adr;
-	adr.sin_family = AF_INET;
+void connect(JNIEnv* e, SOCKET sock, long addr, short port)
+{
+  sockaddr_in adr;
+  adr.sin_family = AF_INET;
 #ifdef PLATFORM_WINDOWS
-	adr.sin_addr.S_un.S_addr = htonl(addr);
+  adr.sin_addr.S_un.S_addr = htonl(addr);
 #else
-	adr.sin_addr.s_addr = htonl(addr);
+  adr.sin_addr.s_addr = htonl(addr);
 #endif
-	adr.sin_port = htons (port);
+  adr.sin_port = htons(port);
 
-	if (SOCKET_ERROR == ::connect(sock, (sockaddr* )&adr, sizeof(adr)))
-	{
-		char buf[255];
-		sprintf(buf, "Can't connect a socket. System error: %d", last_socket_error());
-		throwNew(e, "java/io/IOException", buf);
-		return;
-	}
+  if (SOCKET_ERROR == ::connect(sock, (sockaddr*)&adr, sizeof(adr))) {
+    char buf[255];
+    sprintf(
+        buf, "Can't connect a socket. System error: %d", last_socket_error());
+    throwNew(e, "java/io/IOException", buf);
+    return;
+  }
 }
 
-void bind(JNIEnv* e, SOCKET sock, long addr, short port) {
-	sockaddr_in adr;
-	adr.sin_family = AF_INET;
+void bind(JNIEnv* e, SOCKET sock, long addr, short port)
+{
+  sockaddr_in adr;
+  adr.sin_family = AF_INET;
 #ifdef PLATFORM_WINDOWS
-	adr.sin_addr.S_un.S_addr = htonl(addr);
+  adr.sin_addr.S_un.S_addr = htonl(addr);
 #else
-	adr.sin_addr.s_addr = htonl(addr);
+  adr.sin_addr.s_addr = htonl(addr);
 #endif
-	adr.sin_port = htons (port);
+  adr.sin_port = htons(port);
 
-	if (SOCKET_ERROR == ::bind(sock, (sockaddr* )&adr, sizeof(adr)))
-	{
-		char buf[255];
-		sprintf(buf, "Can't bind a socket. System error: %d", last_socket_error());
-		throwNew(e, "java/io/IOException", buf);
-		return;
-	}
+  if (SOCKET_ERROR == ::bind(sock, (sockaddr*)&adr, sizeof(adr))) {
+    char buf[255];
+    sprintf(buf, "Can't bind a socket. System error: %d", last_socket_error());
+    throwNew(e, "java/io/IOException", buf);
+    return;
+  }
 }
 
-SOCKET accept(JNIEnv* e, SOCKET sock, long* client_addr, short* client_port) {
-	sockaddr_in adr;
-	SOCKET client_socket = ::accept(sock, (sockaddr* )&adr, NULL);
-	if (INVALID_SOCKET == client_socket) {
-		char buf[255];
-		sprintf(buf, "Can't accept the incoming connection. System error: %d", last_socket_error());
-		throwNew(e, "java/io/IOException", buf);
-		return INVALID_SOCKET;
-	}
+SOCKET accept(JNIEnv* e, SOCKET sock, long* client_addr, short* client_port)
+{
+  sockaddr_in adr;
+  SOCKET client_socket = ::accept(sock, (sockaddr*)&adr, NULL);
+  if (INVALID_SOCKET == client_socket) {
+    char buf[255];
+    sprintf(buf,
+            "Can't accept the incoming connection. System error: %d",
+            last_socket_error());
+    throwNew(e, "java/io/IOException", buf);
+    return INVALID_SOCKET;
+  }
 
-	if (client_addr != NULL) {
-	#ifdef PLATFORM_WINDOWS
-		*client_addr = ntohl(adr.sin_addr.S_un.S_addr);
-	#else
-		*client_addr = ntohl(adr.sin_addr.s_addr);
-	#endif
-	}
+  if (client_addr != NULL) {
+#ifdef PLATFORM_WINDOWS
+    *client_addr = ntohl(adr.sin_addr.S_un.S_addr);
+#else
+    *client_addr = ntohl(adr.sin_addr.s_addr);
+#endif
+  }
 
-	if (client_port != NULL) {
-		*client_port = ntohs (adr.sin_port);
-	}
+  if (client_port != NULL) {
+    *client_port = ntohs(adr.sin_port);
+  }
 
-	return client_socket;
+  return client_socket;
 }
 
-void send(JNIEnv* e, SOCKET sock, const char* buff_ptr, int buff_size) {
-	if (SOCKET_ERROR == ::send(sock, buff_ptr, buff_size, 0)) {
-		char buf[255];
-		sprintf(buf, "Can't send data through the socket. System error: %d", last_socket_error());
-		throwNew(e, "java/io/IOException", buf);
-		return;
-	}
+void send(JNIEnv* e, SOCKET sock, const char* buff_ptr, int buff_size)
+{
+  if (SOCKET_ERROR == ::send(sock, buff_ptr, buff_size, 0)) {
+    char buf[255];
+    sprintf(buf,
+            "Can't send data through the socket. System error: %d",
+            last_socket_error());
+    throwNew(e, "java/io/IOException", buf);
+    return;
+  }
 }
 
-int recv(JNIEnv* e, SOCKET sock, char* buff_ptr, int buff_size) {
-	int length = ::recv(sock, buff_ptr, buff_size, 0);
-	if (SOCKET_ERROR == length) {
-		char buf[255];
-		sprintf(buf, "Can't receive data through the socket. System error: %d", last_socket_error());
-		throwNew(e, "java/io/IOException", buf);
-		return 0;	// This doesn't matter cause we have risen an exception
-	}
-	return length;
+int recv(JNIEnv* e, SOCKET sock, char* buff_ptr, int buff_size)
+{
+  int length = ::recv(sock, buff_ptr, buff_size, 0);
+  if (SOCKET_ERROR == length) {
+    char buf[255];
+    sprintf(buf,
+            "Can't receive data through the socket. System error: %d",
+            last_socket_error());
+    throwNew(e, "java/io/IOException", buf);
+    return 0;  // This doesn't matter cause we have risen an exception
+  }
+  return length;
 }
 
-void abort(JNIEnv* e, SOCKET sock) {
-	if (SOCKET_ERROR == ::closesocket(sock)) {
-		char buf[255];
-		sprintf(buf, "Can't close the socket. System error: %d", last_socket_error());
-		throwNew(e, "java/io/IOException", buf);
-	}
+void abort(JNIEnv* e, SOCKET sock)
+{
+  if (SOCKET_ERROR == ::closesocket(sock)) {
+    char buf[255];
+    sprintf(
+        buf, "Can't close the socket. System error: %d", last_socket_error());
+    throwNew(e, "java/io/IOException", buf);
+  }
 }
 
-void close(JNIEnv* e, SOCKET sock) {
-	if (SOCKET_ERROR == ::shutdown(sock, SD_BOTH)) {
-		int errcode = last_socket_error();
-		if (errcode != ENOTCONN) {
-			char buf[255];
-			sprintf(buf, "Can't shutdown the socket. System error: %d", errcode);
-			throwNew(e, "java/io/IOException", buf);
-		}
-	}
+void close(JNIEnv* e, SOCKET sock)
+{
+  if (SOCKET_ERROR == ::shutdown(sock, SD_BOTH)) {
+    int errcode = last_socket_error();
+    if (errcode != ENOTCONN) {
+      char buf[255];
+      sprintf(buf, "Can't shutdown the socket. System error: %d", errcode);
+      throwNew(e, "java/io/IOException", buf);
+    }
+  }
 }
 
-void close_input(JNIEnv* e, SOCKET sock) {
-	if (SOCKET_ERROR == ::shutdown(sock, SD_RECEIVE)) {
-		int errcode = last_socket_error();
-		if (errcode != ENOTCONN) {
-			char buf[255];
-			sprintf(buf, "Can't shutdown the socket. System error: %d", errcode);
-			throwNew(e, "java/io/IOException", buf);
-		}
-	}
-}
-
-void close_output(JNIEnv* e, SOCKET sock) {
-	if (SOCKET_ERROR == ::shutdown(sock, SD_SEND)) {
-		int errcode = last_socket_error();
-		if (errcode != ENOTCONN) {
-			char buf[255];
-			sprintf(buf, "Can't shutdown the socket. System error: %d", errcode);
-			throwNew(e, "java/io/IOException", buf);
-		}
-	}
+void close_input(JNIEnv* e, SOCKET sock)
+{
+  if (SOCKET_ERROR == ::shutdown(sock, SD_RECEIVE)) {
+    int errcode = last_socket_error();
+    if (errcode != ENOTCONN) {
+      char buf[255];
+      sprintf(buf, "Can't shutdown the socket. System error: %d", errcode);
+      throwNew(e, "java/io/IOException", buf);
+    }
+  }
 }
 
+void close_output(JNIEnv* e, SOCKET sock)
+{
+  if (SOCKET_ERROR == ::shutdown(sock, SD_SEND)) {
+    int errcode = last_socket_error();
+    if (errcode != ENOTCONN) {
+      char buf[255];
+      sprintf(buf, "Can't shutdown the socket. System error: %d", errcode);
+      throwNew(e, "java/io/IOException", buf);
+    }
+  }
+}
 }
 }
 }
diff --git a/classpath/sockets.h b/classpath/sockets.h
index 570c70265f..00c968b14b 100644
--- a/classpath/sockets.h
+++ b/classpath/sockets.h
@@ -8,7 +8,6 @@
    There is NO WARRANTY for this software.  See license.txt for
    details. */
 
-
 /*
  * This file represents a simple cross-platform JNI sockets API
  * It is used from different classes of the default Avian classpath
@@ -22,28 +21,28 @@
 #include "jni-util.h"
 
 #ifdef PLATFORM_WINDOWS
-#  include <winsock2.h>
+#include <winsock2.h>
 
-#  define ONLY_ON_WINDOWS(x)	x
+#define ONLY_ON_WINDOWS(x) x
 
-#  ifndef ENOTCONN
-#    define ENOTCONN WSAENOTCONN
-#  endif
+#ifndef ENOTCONN
+#define ENOTCONN WSAENOTCONN
+#endif
 #else
-#  include <netdb.h>
-#  include <sys/socket.h>
-#  include <netinet/in.h>
-#  include <unistd.h>
+#include <netdb.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <unistd.h>
 
-#  define ONLY_ON_WINDOWS(x)
-#  define SOCKET				int
-#  define INVALID_SOCKET		-1
-#  define SOCKET_ERROR			-1
-#  define closesocket(x)		close(x)
+#define ONLY_ON_WINDOWS(x)
+#define SOCKET int
+#define INVALID_SOCKET -1
+#define SOCKET_ERROR -1
+#define closesocket(x) close(x)
 
-#  define SD_RECEIVE			SHUT_RD
-#  define SD_SEND				SHUT_WR
-#  define SD_BOTH				SHUT_RDWR
+#define SD_RECEIVE SHUT_RD
+#define SD_SEND SHUT_WR
+#define SD_BOTH SHUT_RDWR
 
 #endif
 
@@ -69,7 +68,6 @@ void abort(JNIEnv* e, SOCKET sock);
 void close(JNIEnv* e, SOCKET sock);
 void close_input(JNIEnv* e, SOCKET sock);
 void close_output(JNIEnv* e, SOCKET sock);
-
 }
 }
 }
diff --git a/include/avian/codegen/architecture.h b/include/avian/codegen/architecture.h
index 0c82fbc207..91a41551f0 100644
--- a/include/avian/codegen/architecture.h
+++ b/include/avian/codegen/architecture.h
@@ -30,116 +30,126 @@ class Assembler;
 class RegisterFile;
 
 class OperandMask {
-public:
+ public:
   uint8_t typeMask;
   uint64_t registerMask;
 
-  OperandMask(uint8_t typeMask, uint64_t registerMask):
-    typeMask(typeMask),
-    registerMask(registerMask)
-  { }
+  OperandMask(uint8_t typeMask, uint64_t registerMask)
+      : typeMask(typeMask), registerMask(registerMask)
+  {
+  }
 
-  OperandMask():
-    typeMask(~0),
-    registerMask(~static_cast<uint64_t>(0))
-  { }
+  OperandMask() : typeMask(~0), registerMask(~static_cast<uint64_t>(0))
+  {
+  }
 };
 
 class Architecture {
-public:
-virtual unsigned floatRegisterSize() = 0;
+ public:
+  virtual unsigned floatRegisterSize() = 0;
 
-virtual const RegisterFile* registerFile() = 0;
+  virtual const RegisterFile* registerFile() = 0;
 
-virtual int scratch() = 0;
-virtual int stack() = 0;
-virtual int thread() = 0;
-virtual int returnLow() = 0;
-virtual int returnHigh() = 0;
-virtual int virtualCallTarget() = 0;
-virtual int virtualCallIndex() = 0;
+  virtual int scratch() = 0;
+  virtual int stack() = 0;
+  virtual int thread() = 0;
+  virtual int returnLow() = 0;
+  virtual int returnHigh() = 0;
+  virtual int virtualCallTarget() = 0;
+  virtual int virtualCallIndex() = 0;
 
-virtual ir::TargetInfo targetInfo() = 0;
+  virtual ir::TargetInfo targetInfo() = 0;
 
-virtual bool bigEndian() = 0;
+  virtual bool bigEndian() = 0;
 
-virtual uintptr_t maximumImmediateJump() = 0;
+  virtual uintptr_t maximumImmediateJump() = 0;
 
-virtual bool alwaysCondensed(lir::BinaryOperation op) = 0;
-virtual bool alwaysCondensed(lir::TernaryOperation op) = 0;
+  virtual bool alwaysCondensed(lir::BinaryOperation op) = 0;
+  virtual bool alwaysCondensed(lir::TernaryOperation op) = 0;
 
-virtual bool reserved(int register_) = 0;
+  virtual bool reserved(int register_) = 0;
 
-virtual unsigned frameFootprint(unsigned footprint) = 0;
-virtual unsigned argumentFootprint(unsigned footprint) = 0;
-virtual bool argumentAlignment() = 0;
-virtual bool argumentRegisterAlignment() = 0;
-virtual unsigned argumentRegisterCount() = 0;
-virtual int argumentRegister(unsigned index) = 0;
+  virtual unsigned frameFootprint(unsigned footprint) = 0;
+  virtual unsigned argumentFootprint(unsigned footprint) = 0;
+  virtual bool argumentAlignment() = 0;
+  virtual bool argumentRegisterAlignment() = 0;
+  virtual unsigned argumentRegisterCount() = 0;
+  virtual int argumentRegister(unsigned index) = 0;
 
-virtual bool hasLinkRegister() = 0;
+  virtual bool hasLinkRegister() = 0;
 
-virtual unsigned stackAlignmentInWords() = 0;
+  virtual unsigned stackAlignmentInWords() = 0;
 
-virtual bool matchCall(void* returnAddress, void* target) = 0;
+  virtual bool matchCall(void* returnAddress, void* target) = 0;
 
-virtual void updateCall(lir::UnaryOperation op, void* returnAddress,
-                        void* newTarget) = 0;
+  virtual void updateCall(lir::UnaryOperation op,
+                          void* returnAddress,
+                          void* newTarget) = 0;
 
-virtual void setConstant(void* dst, uint64_t constant) = 0;
+  virtual void setConstant(void* dst, uint64_t constant) = 0;
 
-virtual unsigned alignFrameSize(unsigned sizeInWords) = 0;
+  virtual unsigned alignFrameSize(unsigned sizeInWords) = 0;
 
-virtual void nextFrame(void* start, unsigned size, unsigned footprint,
-                       void* link, bool mostRecent,
-                       int targetParameterFootprint, void** ip,
-                       void** stack) = 0;
-virtual void* frameIp(void* stack) = 0;
-virtual unsigned frameHeaderSize() = 0;
-virtual unsigned frameReturnAddressSize() = 0;
-virtual unsigned frameFooterSize() = 0;
-virtual int returnAddressOffset() = 0;
-virtual int framePointerOffset() = 0;
+  virtual void nextFrame(void* start,
+                         unsigned size,
+                         unsigned footprint,
+                         void* link,
+                         bool mostRecent,
+                         int targetParameterFootprint,
+                         void** ip,
+                         void** stack) = 0;
+  virtual void* frameIp(void* stack) = 0;
+  virtual unsigned frameHeaderSize() = 0;
+  virtual unsigned frameReturnAddressSize() = 0;
+  virtual unsigned frameFooterSize() = 0;
+  virtual int returnAddressOffset() = 0;
+  virtual int framePointerOffset() = 0;
 
-virtual void plan
-(lir::UnaryOperation op,
- unsigned aSize, OperandMask& aMask,
- bool* thunk) = 0;
+  virtual void plan(lir::UnaryOperation op,
+                    unsigned aSize,
+                    OperandMask& aMask,
+                    bool* thunk) = 0;
 
-virtual void planSource
-(lir::BinaryOperation op,
- unsigned aSize, OperandMask& aMask,
- unsigned bSize, bool* thunk) = 0;
- 
-virtual void planDestination
-(lir::BinaryOperation op,
- unsigned aSize, const OperandMask& aMask,
- unsigned bSize, OperandMask& bMask) = 0;
+  virtual void planSource(lir::BinaryOperation op,
+                          unsigned aSize,
+                          OperandMask& aMask,
+                          unsigned bSize,
+                          bool* thunk) = 0;
 
-virtual void planMove
-(unsigned size, OperandMask& src,
- OperandMask& tmp,
- const OperandMask& dst) = 0; 
+  virtual void planDestination(lir::BinaryOperation op,
+                               unsigned aSize,
+                               const OperandMask& aMask,
+                               unsigned bSize,
+                               OperandMask& bMask) = 0;
 
-virtual void planSource
-(lir::TernaryOperation op,
- unsigned aSize, OperandMask& aMask,
- unsigned bSize, OperandMask& bMask,
- unsigned cSize, bool* thunk) = 0; 
+  virtual void planMove(unsigned size,
+                        OperandMask& src,
+                        OperandMask& tmp,
+                        const OperandMask& dst) = 0;
 
-virtual void planDestination
-(lir::TernaryOperation op,
- unsigned aSize, const OperandMask& aMask,
- unsigned bSize, const OperandMask& bMask,
- unsigned cSize, OperandMask& cMask) = 0;
+  virtual void planSource(lir::TernaryOperation op,
+                          unsigned aSize,
+                          OperandMask& aMask,
+                          unsigned bSize,
+                          OperandMask& bMask,
+                          unsigned cSize,
+                          bool* thunk) = 0;
 
-virtual Assembler* makeAssembler(util::Allocator*, vm::Zone*) = 0;
+  virtual void planDestination(lir::TernaryOperation op,
+                               unsigned aSize,
+                               const OperandMask& aMask,
+                               unsigned bSize,
+                               const OperandMask& bMask,
+                               unsigned cSize,
+                               OperandMask& cMask) = 0;
 
-virtual void acquire() = 0;
-virtual void release() = 0;
+  virtual Assembler* makeAssembler(util::Allocator*, vm::Zone*) = 0;
+
+  virtual void acquire() = 0;
+  virtual void release() = 0;
 };
 
-} // namespace codegen
-} // namespace avian
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_ARCHITECTURE_H
+#endif  // AVIAN_CODEGEN_ARCHITECTURE_H
diff --git a/include/avian/codegen/assembler.h b/include/avian/codegen/assembler.h
index 49a7664d6d..66e7ed53d6 100644
--- a/include/avian/codegen/assembler.h
+++ b/include/avian/codegen/assembler.h
@@ -23,16 +23,17 @@ namespace codegen {
 class Architecture;
 
 class OperandInfo {
-public:
+ public:
   const unsigned size;
   const lir::OperandType type;
   lir::Operand* const operand;
 
-  inline OperandInfo(unsigned size, lir::OperandType type, lir::Operand* operand):
-    size(size),
-    type(type),
-    operand(operand)
-  { }
+  inline OperandInfo(unsigned size,
+                     lir::OperandType type,
+                     lir::Operand* operand)
+      : size(size), type(type), operand(operand)
+  {
+  }
 };
 
 #ifdef AVIAN_TAILS
@@ -49,11 +50,9 @@ const bool UseFramePointer = false;
 
 class Assembler {
  public:
-
   class Client {
    public:
-    virtual int acquireTemporary
-    (uint32_t mask = ~static_cast<uint32_t>(0)) = 0;
+    virtual int acquireTemporary(uint32_t mask = ~static_cast<uint32_t>(0)) = 0;
     virtual void releaseTemporary(int r) = 0;
 
     virtual void save(int r) = 0;
@@ -75,20 +74,23 @@ class Assembler {
   virtual void allocateFrame(unsigned footprint) = 0;
   virtual void adjustFrame(unsigned difference) = 0;
   virtual void popFrame(unsigned footprint) = 0;
-  virtual void popFrameForTailCall(unsigned footprint, int offset,
+  virtual void popFrameForTailCall(unsigned footprint,
+                                   int offset,
                                    int returnAddressSurrogate,
                                    int framePointerSurrogate) = 0;
   virtual void popFrameAndPopArgumentsAndReturn(unsigned frameFootprint,
-                                                unsigned argumentFootprint)
-  = 0;
+                                                unsigned argumentFootprint) = 0;
   virtual void popFrameAndUpdateStackAndReturn(unsigned frameFootprint,
                                                unsigned stackOffsetFromThread)
-  = 0;
+      = 0;
 
   virtual void apply(lir::Operation op) = 0;
   virtual void apply(lir::UnaryOperation op, OperandInfo a) = 0;
   virtual void apply(lir::BinaryOperation op, OperandInfo a, OperandInfo b) = 0;
-  virtual void apply(lir::TernaryOperation op, OperandInfo a, OperandInfo b, OperandInfo c) = 0;
+  virtual void apply(lir::TernaryOperation op,
+                     OperandInfo a,
+                     OperandInfo b,
+                     OperandInfo c) = 0;
 
   virtual void setDestination(uint8_t* dst) = 0;
 
@@ -107,7 +109,7 @@ class Assembler {
   virtual void dispose() = 0;
 };
 
-} // namespace codegen
-} // namespace avian
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_ASSEMBLER_H
+#endif  // AVIAN_CODEGEN_ASSEMBLER_H
diff --git a/include/avian/codegen/compiler.h b/include/avian/codegen/compiler.h
index 099ae15ca5..6b38e91054 100644
--- a/include/avian/codegen/compiler.h
+++ b/include/avian/codegen/compiler.h
@@ -30,24 +30,30 @@ class Compiler {
   class Client {
    public:
     virtual intptr_t getThunk(lir::UnaryOperation op, unsigned size) = 0;
-    virtual intptr_t getThunk(lir::BinaryOperation op, unsigned size,
+    virtual intptr_t getThunk(lir::BinaryOperation op,
+                              unsigned size,
                               unsigned resultSize) = 0;
-    virtual intptr_t getThunk(lir::TernaryOperation op, unsigned size,
-                              unsigned resultSize, bool* threadParameter) = 0;
+    virtual intptr_t getThunk(lir::TernaryOperation op,
+                              unsigned size,
+                              unsigned resultSize,
+                              bool* threadParameter) = 0;
   };
 
-  static const unsigned Aligned  = 1 << 0;
+  static const unsigned Aligned = 1 << 0;
   static const unsigned NoReturn = 1 << 1;
   static const unsigned TailJump = 1 << 2;
   static const unsigned LongJumpOrCall = 1 << 3;
 
-  class State { };
+  class State {
+  };
 
   virtual State* saveState() = 0;
   virtual void restoreState(State* state) = 0;
 
-  virtual void init(unsigned logicalCodeSize, unsigned parameterFootprint,
-                    unsigned localFootprint, unsigned alignedFrameSize) = 0;
+  virtual void init(unsigned logicalCodeSize,
+                    unsigned parameterFootprint,
+                    unsigned localFootprint,
+                    unsigned alignedFrameSize) = 0;
 
   virtual void extendLogicalCode(unsigned more) = 0;
 
@@ -128,8 +134,7 @@ class Compiler {
                               ir::Type type,
                               ir::Value* a,
                               ir::Value* b) = 0;
-  virtual ir::Value* unaryOp(lir::BinaryOperation op,
-                             ir::Value* a) = 0;
+  virtual ir::Value* unaryOp(lir::BinaryOperation op, ir::Value* a) = 0;
   virtual void nullaryOp(lir::Operation op) = 0;
 
   virtual ir::Value* f2f(ir::Type resType, ir::Value* a) = 0;
@@ -145,11 +150,12 @@ class Compiler {
   virtual void dispose() = 0;
 };
 
-Compiler*
-makeCompiler(vm::System* system, Assembler* assembler, vm::Zone* zone,
-             Compiler::Client* client);
+Compiler* makeCompiler(vm::System* system,
+                       Assembler* assembler,
+                       vm::Zone* zone,
+                       Compiler::Client* client);
 
-} // namespace codegen
-} // namespace avian
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_COMPILER_H
+#endif  // AVIAN_CODEGEN_COMPILER_H
diff --git a/include/avian/codegen/lir.h b/include/avian/codegen/lir.h
index a8b48ce8c2..251e31aadd 100644
--- a/include/avian/codegen/lir.h
+++ b/include/avian/codegen/lir.h
@@ -17,71 +17,67 @@ class Promise;
 
 namespace lir {
 enum Operation {
-  #define LIR_OP_0(x) x,
-  #define LIR_OP_1(x)
-  #define LIR_OP_2(x)
-  #define LIR_OP_3(x)
-  #include "lir-ops.inc.cpp"
-  #undef LIR_OP_0
-  #undef LIR_OP_1
-  #undef LIR_OP_2
-  #undef LIR_OP_3
+#define LIR_OP_0(x) x,
+#define LIR_OP_1(x)
+#define LIR_OP_2(x)
+#define LIR_OP_3(x)
+#include "lir-ops.inc.cpp"
+#undef LIR_OP_0
+#undef LIR_OP_1
+#undef LIR_OP_2
+#undef LIR_OP_3
 };
 
 const unsigned OperationCount = Trap + 1;
 
 enum UnaryOperation {
-  #define LIR_OP_0(x)
-  #define LIR_OP_1(x) x,
-  #define LIR_OP_2(x)
-  #define LIR_OP_3(x)
-  #include "lir-ops.inc.cpp"
-  #undef LIR_OP_0
-  #undef LIR_OP_1
-  #undef LIR_OP_2
-  #undef LIR_OP_3
-  
+#define LIR_OP_0(x)
+#define LIR_OP_1(x) x,
+#define LIR_OP_2(x)
+#define LIR_OP_3(x)
+#include "lir-ops.inc.cpp"
+#undef LIR_OP_0
+#undef LIR_OP_1
+#undef LIR_OP_2
+#undef LIR_OP_3
   NoUnaryOperation = -1
 };
 
 const unsigned UnaryOperationCount = AlignedJump + 1;
 
 enum BinaryOperation {
-  #define LIR_OP_0(x)
-  #define LIR_OP_1(x)
-  #define LIR_OP_2(x) x,
-  #define LIR_OP_3(x)
-  #include "lir-ops.inc.cpp"
-  #undef LIR_OP_0
-  #undef LIR_OP_1
-  #undef LIR_OP_2
-  #undef LIR_OP_3
-  
+#define LIR_OP_0(x)
+#define LIR_OP_1(x)
+#define LIR_OP_2(x) x,
+#define LIR_OP_3(x)
+#include "lir-ops.inc.cpp"
+#undef LIR_OP_0
+#undef LIR_OP_1
+#undef LIR_OP_2
+#undef LIR_OP_3
   NoBinaryOperation = -1
 };
 
 const unsigned BinaryOperationCount = Absolute + 1;
 
 enum TernaryOperation {
-  #define LIR_OP_0(x)
-  #define LIR_OP_1(x)
-  #define LIR_OP_2(x)
-  #define LIR_OP_3(x) x,
-  #include "lir-ops.inc.cpp"
-  #undef LIR_OP_0
-  #undef LIR_OP_1
-  #undef LIR_OP_2
-  #undef LIR_OP_3
-  
+#define LIR_OP_0(x)
+#define LIR_OP_1(x)
+#define LIR_OP_2(x)
+#define LIR_OP_3(x) x,
+#include "lir-ops.inc.cpp"
+#undef LIR_OP_0
+#undef LIR_OP_1
+#undef LIR_OP_2
+#undef LIR_OP_3
   NoTernaryOperation = -1
 };
 
-const unsigned TernaryOperationCount
-= JumpIfFloatGreaterOrEqualOrUnordered + 1;
+const unsigned TernaryOperationCount = JumpIfFloatGreaterOrEqualOrUnordered + 1;
 
 const unsigned NonBranchTernaryOperationCount = FloatMin + 1;
-const unsigned BranchOperationCount
-= JumpIfFloatGreaterOrEqualOrUnordered - FloatMin;
+const unsigned BranchOperationCount = JumpIfFloatGreaterOrEqualOrUnordered
+                                      - FloatMin;
 
 enum OperandType {
   ConstantOperand,
@@ -90,72 +86,84 @@ enum OperandType {
   MemoryOperand
 };
 
-enum ValueType {
-  ValueGeneral,
-  ValueFloat
-};
+enum ValueType { ValueGeneral, ValueFloat };
 
 const unsigned OperandTypeCount = MemoryOperand + 1;
 
 const int NoRegister = -1;
 
-inline bool isBranch(lir::TernaryOperation op) {
+inline bool isBranch(lir::TernaryOperation op)
+{
   return op > FloatMin;
 }
 
-inline bool isFloatBranch(lir::TernaryOperation op) {
+inline bool isFloatBranch(lir::TernaryOperation op)
+{
   return op > JumpIfNotEqual;
 }
 
-inline bool isGeneralBranch(lir::TernaryOperation op) {
+inline bool isGeneralBranch(lir::TernaryOperation op)
+{
   return isBranch(op) && !isFloatBranch(op);
 }
 
-inline bool isGeneralBinaryOp(lir::TernaryOperation op) {
+inline bool isGeneralBinaryOp(lir::TernaryOperation op)
+{
   return op < FloatAdd;
 }
 
-inline bool isFloatBinaryOp(lir::TernaryOperation op) {
+inline bool isFloatBinaryOp(lir::TernaryOperation op)
+{
   return op >= FloatAdd && op <= FloatMin;
 }
 
-inline bool isGeneralUnaryOp(lir::BinaryOperation op) {
+inline bool isGeneralUnaryOp(lir::BinaryOperation op)
+{
   return op == Negate || op == Absolute;
 }
 
-inline bool isFloatUnaryOp(lir::BinaryOperation op) {
+inline bool isFloatUnaryOp(lir::BinaryOperation op)
+{
   return op == FloatNegate || op == FloatSquareRoot || op == FloatAbsolute;
 }
 
-class Operand { };
+class Operand {
+};
 
-class Constant: public Operand {
+class Constant : public Operand {
  public:
-  Constant(Promise* value): value(value) { }
+  Constant(Promise* value) : value(value)
+  {
+  }
 
   Promise* value;
 };
 
-class Address: public Operand {
+class Address : public Operand {
  public:
-  Address(Promise* address): address(address) { }
+  Address(Promise* address) : address(address)
+  {
+  }
 
   Promise* address;
 };
 
-class Register: public Operand {
+class Register : public Operand {
  public:
-  Register(int low, int high = NoRegister): low(low), high(high) { }
+  Register(int low, int high = NoRegister) : low(low), high(high)
+  {
+  }
 
   int low;
   int high;
 };
 
-class Memory: public Operand {
+class Memory : public Operand {
  public:
-  Memory(int base, int offset, int index = NoRegister, unsigned scale = 1):
-    base(base), offset(offset), index(index), scale(scale)
-  { }
+  Memory(int base, int offset, int index = NoRegister, unsigned scale = 1)
+      : base(base), offset(offset), index(index), scale(scale)
+  {
+  }
 
   int base;
   int offset;
@@ -163,8 +171,8 @@ class Memory: public Operand {
   unsigned scale;
 };
 
-} // namespace lir
-} // namespace codegen
-} // namespace avian
+}  // namespace lir
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_LIR_H
+#endif  // AVIAN_CODEGEN_LIR_H
diff --git a/include/avian/codegen/promise.h b/include/avian/codegen/promise.h
index 7c0713dab1..6d683533dc 100644
--- a/include/avian/codegen/promise.h
+++ b/include/avian/codegen/promise.h
@@ -29,35 +29,45 @@ class Promise {
 
   virtual int64_t value() = 0;
   virtual bool resolved() = 0;
-  virtual Listener* listen(unsigned) { return 0; }
+  virtual Listener* listen(unsigned)
+  {
+    return 0;
+  }
 };
 
-class ResolvedPromise: public Promise {
+class ResolvedPromise : public Promise {
  public:
-  ResolvedPromise(int64_t value): value_(value) { }
+  ResolvedPromise(int64_t value) : value_(value)
+  {
+  }
 
-  virtual int64_t value() {
+  virtual int64_t value()
+  {
     return value_;
   }
 
-  virtual bool resolved() {
+  virtual bool resolved()
+  {
     return true;
   }
 
   int64_t value_;
 };
 
-class ShiftMaskPromise: public Promise {
+class ShiftMaskPromise : public Promise {
  public:
-  ShiftMaskPromise(Promise* base, unsigned shift, int64_t mask):
-    base(base), shift(shift), mask(mask)
-  { }
+  ShiftMaskPromise(Promise* base, unsigned shift, int64_t mask)
+      : base(base), shift(shift), mask(mask)
+  {
+  }
 
-  virtual int64_t value() {
+  virtual int64_t value()
+  {
     return (base->value() >> shift) & mask;
   }
 
-  virtual bool resolved() {
+  virtual bool resolved()
+  {
     return base->resolved();
   }
 
@@ -66,17 +76,19 @@ class ShiftMaskPromise: public Promise {
   int64_t mask;
 };
 
-class CombinedPromise: public Promise {
+class CombinedPromise : public Promise {
  public:
-  CombinedPromise(Promise* low, Promise* high):
-    low(low), high(high)
-  { }
+  CombinedPromise(Promise* low, Promise* high) : low(low), high(high)
+  {
+  }
 
-  virtual int64_t value() {
+  virtual int64_t value()
+  {
     return low->value() | (high->value() << 32);
   }
 
-  virtual bool resolved() {
+  virtual bool resolved()
+  {
     return low->resolved() and high->resolved();
   }
 
@@ -84,17 +96,19 @@ class CombinedPromise: public Promise {
   Promise* high;
 };
 
-class OffsetPromise: public Promise {
+class OffsetPromise : public Promise {
  public:
-  OffsetPromise(Promise* base, int64_t offset):
-    base(base), offset(offset)
-  { }
+  OffsetPromise(Promise* base, int64_t offset) : base(base), offset(offset)
+  {
+  }
 
-  virtual int64_t value() {
+  virtual int64_t value()
+  {
     return base->value() + offset;
   }
 
-  virtual bool resolved() {
+  virtual bool resolved()
+  {
     return base->resolved();
   }
 
@@ -102,21 +116,25 @@ class OffsetPromise: public Promise {
   int64_t offset;
 };
 
-class ListenPromise: public Promise {
+class ListenPromise : public Promise {
  public:
   ListenPromise(vm::System* s, util::Allocator* allocator)
       : s(s), allocator(allocator), listener(0)
-  { }
+  {
+  }
 
-  virtual int64_t value() {
+  virtual int64_t value()
+  {
     abort(s);
   }
 
-  virtual bool resolved() {
+  virtual bool resolved()
+  {
     return false;
   }
 
-  virtual Listener* listen(unsigned sizeInBytes) {
+  virtual Listener* listen(unsigned sizeInBytes)
+  {
     Listener* l = static_cast<Listener*>(allocator->allocate(sizeInBytes));
     l->next = listener;
     listener = l;
@@ -129,24 +147,28 @@ class ListenPromise: public Promise {
   Promise* promise;
 };
 
-class DelayedPromise: public ListenPromise {
+class DelayedPromise : public ListenPromise {
  public:
   DelayedPromise(vm::System* s,
                  util::Allocator* allocator,
                  Promise* basis,
                  DelayedPromise* next)
       : ListenPromise(s, allocator), basis(basis), next(next)
-  { }
+  {
+  }
 
-  virtual int64_t value() {
+  virtual int64_t value()
+  {
     abort(s);
   }
 
-  virtual bool resolved() {
+  virtual bool resolved()
+  {
     return false;
   }
 
-  virtual Listener* listen(unsigned sizeInBytes) {
+  virtual Listener* listen(unsigned sizeInBytes)
+  {
     Listener* l = static_cast<Listener*>(allocator->allocate(sizeInBytes));
     l->next = listener;
     listener = l;
@@ -157,7 +179,7 @@ class DelayedPromise: public ListenPromise {
   DelayedPromise* next;
 };
 
-} // namespace codegen
-} // namespace avian
+}  // namespace codegen
+}  // namespace avian
 
 #endif  // AVIAN_CODEGEN_PROMISE_H
diff --git a/include/avian/codegen/registers.h b/include/avian/codegen/registers.h
index b46b76570d..f152084605 100644
--- a/include/avian/codegen/registers.h
+++ b/include/avian/codegen/registers.h
@@ -17,7 +17,7 @@ namespace avian {
 namespace codegen {
 
 class RegisterMask {
-public:
+ public:
   uint32_t mask;
   uint8_t start;
   uint8_t limit;
@@ -25,49 +25,52 @@ public:
   static unsigned maskStart(uint32_t mask);
   static unsigned maskLimit(uint32_t mask);
 
-  inline RegisterMask(uint32_t mask):
-    mask(mask),
-    start(maskStart(mask)),
-    limit(maskLimit(mask))
-  { }
+  inline RegisterMask(uint32_t mask)
+      : mask(mask), start(maskStart(mask)), limit(maskLimit(mask))
+  {
+  }
 };
 
 class RegisterFile {
-public:
+ public:
   RegisterMask allRegisters;
   RegisterMask generalRegisters;
   RegisterMask floatRegisters;
 
-  inline RegisterFile(uint32_t generalRegisterMask, uint32_t floatRegisterMask):
-    allRegisters(generalRegisterMask | floatRegisterMask),
-    generalRegisters(generalRegisterMask),
-    floatRegisters(floatRegisterMask)
-  { }
+  inline RegisterFile(uint32_t generalRegisterMask, uint32_t floatRegisterMask)
+      : allRegisters(generalRegisterMask | floatRegisterMask),
+        generalRegisters(generalRegisterMask),
+        floatRegisters(floatRegisterMask)
+  {
+  }
 };
 
 class RegisterIterator {
-public:
+ public:
   int index;
   const RegisterMask& mask;
 
-  inline RegisterIterator(const RegisterMask& mask):
-    index(mask.start),
-    mask(mask) {}
+  inline RegisterIterator(const RegisterMask& mask)
+      : index(mask.start), mask(mask)
+  {
+  }
 
-  inline bool hasNext() {
+  inline bool hasNext()
+  {
     return index < mask.limit;
   }
 
-  inline int next() {
+  inline int next()
+  {
     int r = index;
     do {
       index++;
-    } while(index < mask.limit && !(mask.mask & (1 << index)));
+    } while (index < mask.limit && !(mask.mask & (1 << index)));
     return r;
   }
 };
 
-} // namespace codegen
-} // namespace avian
+}  // namespace codegen
+}  // namespace avian
 
 #endif  // AVIAN_CODEGEN_REGISTERS_H
diff --git a/include/avian/codegen/runtime.h b/include/avian/codegen/runtime.h
index 4f31e65871..c69e8773e7 100644
--- a/include/avian/codegen/runtime.h
+++ b/include/avian/codegen/runtime.h
@@ -47,8 +47,8 @@ uint64_t intToFloat(int32_t a);
 uint64_t longToDouble(int64_t a);
 uint64_t longToFloat(int64_t a);
 
-} // namespace runtime
-} // namespace codegen
-} // namespace avian
+}  // namespace runtime
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_RUNTIME_H
+#endif  // AVIAN_CODEGEN_RUNTIME_H
diff --git a/include/avian/codegen/targets.h b/include/avian/codegen/targets.h
index 9e8eb8a335..0169c6025f 100644
--- a/include/avian/codegen/targets.h
+++ b/include/avian/codegen/targets.h
@@ -20,12 +20,13 @@ namespace codegen {
 
 class Architecture;
 
-Architecture* makeArchitectureNative(vm::System* system, bool useNativeFeatures);
+Architecture* makeArchitectureNative(vm::System* system,
+                                     bool useNativeFeatures);
 
 Architecture* makeArchitectureX86(vm::System* system, bool useNativeFeatures);
 Architecture* makeArchitectureArm(vm::System* system, bool useNativeFeatures);
 
-} // namespace codegen
-} // namespace avian
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_TARGETS_H
+#endif  // AVIAN_CODEGEN_TARGETS_H
diff --git a/include/avian/heap/heap.h b/include/avian/heap/heap.h
index 45b6659efe..e336bd3341 100644
--- a/include/avian/heap/heap.h
+++ b/include/avian/heap/heap.h
@@ -24,17 +24,9 @@ const unsigned FixieTenureThreshold = TenureThreshold + 2;
 
 class Heap : public avian::util::Allocator {
  public:
-  enum CollectionType {
-    MinorCollection,
-    MajorCollection
-  };
+  enum CollectionType { MinorCollection, MajorCollection };
 
-  enum Status {
-    Null,
-    Reachable,
-    Unreachable,
-    Tenured
-  };
+  enum Status { Null, Reachable, Unreachable, Tenured };
 
   class Visitor {
    public:
@@ -62,7 +54,8 @@ class Heap : public avian::util::Allocator {
   virtual unsigned remaining() = 0;
   virtual unsigned limit() = 0;
   virtual bool limitExceeded(int pendingAllocation = 0) = 0;
-  virtual void collect(CollectionType type, unsigned footprint,
+  virtual void collect(CollectionType type,
+                       unsigned footprint,
                        int pendingAllocation) = 0;
   virtual unsigned fixedFootprint(unsigned sizeInWords, bool objectMask) = 0;
   virtual void* allocateFixed(avian::util::Allocator* allocator,
@@ -90,6 +83,6 @@ class Heap : public avian::util::Allocator {
 
 Heap* makeHeap(System* system, unsigned limit);
 
-} // namespace vm
+}  // namespace vm
 
-#endif//HEAP_H
+#endif  // HEAP_H
diff --git a/include/avian/system/signal.h b/include/avian/system/signal.h
index 092491e1bc..60c9a1fb28 100644
--- a/include/avian/system/signal.h
+++ b/include/avian/system/signal.h
@@ -21,7 +21,8 @@ namespace system {
 // order to trigger the crash dump logic.
 NO_RETURN void crash();
 
-// Registrar for unix-like "signals" (implemented with structured exceptions on windows).
+// Registrar for unix-like "signals" (implemented with structured exceptions on
+// windows).
 // TODO: remove dependence on generated code having a well-known "thread"
 // register. Use a thread-local variable instead.
 class SignalRegistrar {
@@ -40,7 +41,6 @@ class SignalRegistrar {
     // "Segmentation fault" exceptions (mostly null pointer dereference, but
     // generally access to any non-mapped memory)
     SegFault,
-
     DivideByZero,
   };
 
@@ -72,11 +72,10 @@ class SignalRegistrar {
   struct Data;
 
  private:
-
   Data* data;
 };
 
-} // namespace system
-} // namespace avian
+}  // namespace system
+}  // namespace avian
 
 #endif
diff --git a/include/avian/system/system.h b/include/avian/system/system.h
index 8eb0e498de..ea31823f46 100644
--- a/include/avian/system/system.h
+++ b/include/avian/system/system.h
@@ -21,12 +21,7 @@ class System : public avian::util::Aborter {
  public:
   typedef intptr_t Status;
 
-  enum FileType {
-    TypeUnknown,
-    TypeDoesNotExist,
-    TypeFile,
-    TypeDirectory
-  };
+  enum FileType { TypeUnknown, TypeDoesNotExist, TypeFile, TypeDirectory };
 
   class Thread {
    public:
@@ -100,11 +95,13 @@ class System : public avian::util::Aborter {
 
   class MonitorResource {
    public:
-    MonitorResource(System::Thread* t, System::Monitor* m): t(t), m(m) {
+    MonitorResource(System::Thread* t, System::Monitor* m) : t(t), m(m)
+    {
       m->acquire(t);
     }
 
-    ~MonitorResource() {
+    ~MonitorResource()
+    {
       m->release(t);
     }
 
@@ -126,8 +123,8 @@ class System : public avian::util::Aborter {
   virtual Status make(Monitor**) = 0;
   virtual Status make(Local**) = 0;
 
-  virtual Status visit(Thread* thread, Thread* target,
-                       ThreadVisitor* visitor) = 0;
+  virtual Status visit(Thread* thread, Thread* target, ThreadVisitor* visitor)
+      = 0;
 
   virtual Status map(Region**, const char* name) = 0;
   virtual FileType stat(const char* name, unsigned* length) = 0;
@@ -145,23 +142,23 @@ class System : public avian::util::Aborter {
   virtual void dispose() = 0;
 };
 
-inline void*
-allocate(System* s, unsigned size)
+inline void* allocate(System* s, unsigned size)
 {
   void* p = s->tryAllocate(size);
-  if (p == 0) s->abort();
+  if (p == 0)
+    s->abort();
   return p;
 }
 
 #define ACQUIRE_MONITOR(t, m) \
-  System::MonitorResource MAKE_NAME(monitorResource_) (t, m)
+  System::MonitorResource MAKE_NAME(monitorResource_)(t, m)
 
-inline avian::util::Aborter* getAborter(System* s) {
+inline avian::util::Aborter* getAborter(System* s)
+{
   return s;
 }
 
-inline void NO_RETURN
-sysAbort(System* s)
+inline void NO_RETURN sysAbort(System* s)
 {
   abort(s);
 }
@@ -183,9 +180,8 @@ sysAbort(System* s)
 
 // #endif // not NDEBUG
 
-AVIAN_EXPORT System*
-makeSystem();
+AVIAN_EXPORT System* makeSystem();
 
-} // namespace vm
+}  // namespace vm
 
-#endif//SYSTEM_H
+#endif  // SYSTEM_H
diff --git a/include/avian/tools/object-writer/tools.h b/include/avian/tools/object-writer/tools.h
index 1785a0c5a8..ea7651de5c 100644
--- a/include/avian/tools/object-writer/tools.h
+++ b/include/avian/tools/object-writer/tools.h
@@ -23,16 +23,17 @@ namespace avian {
 namespace tools {
 
 class OutputStream {
-public:
+ public:
   virtual void writeChunk(const void* data, size_t size) = 0;
   virtual void write(uint8_t byte);
   virtual void writeRepeat(uint8_t byte, size_t size);
 };
 
 class FileOutputStream : public OutputStream {
-private:
+ private:
   FILE* file;
-public:
+
+ public:
   FileOutputStream(const char* name);
   ~FileOutputStream();
 
@@ -43,20 +44,22 @@ public:
 };
 
 class SymbolInfo {
-public:
+ public:
   unsigned addr;
   util::String name;
 
-  inline SymbolInfo(uint64_t addr, const util::String& name):
-    addr(addr),
-    name(name) {}
+  inline SymbolInfo(uint64_t addr, const util::String& name)
+      : addr(addr), name(name)
+  {
+  }
 
-  inline SymbolInfo():
-    name("") {}
+  inline SymbolInfo() : name("")
+  {
+  }
 };
 
 class Buffer {
-public:
+ public:
   size_t capacity;
   size_t length;
   uint8_t* data;
@@ -69,7 +72,7 @@ public:
 };
 
 class StringTable : public Buffer {
-public:
+ public:
   unsigned add(util::String str);
 };
 
@@ -103,7 +106,7 @@ class DynamicArray : public util::Slice<T> {
 };
 
 class PlatformInfo {
-public:
+ public:
   enum Format {
     Elf = AVIAN_FORMAT_ELF,
     Pe = AVIAN_FORMAT_PE,
@@ -124,33 +127,31 @@ public:
   static Format formatFromString(const char* format);
   static Architecture archFromString(const char* arch);
 
-  inline PlatformInfo(Format format, Architecture arch):
-    format(format),
-    arch(arch) {}
+  inline PlatformInfo(Format format, Architecture arch)
+      : format(format), arch(arch)
+  {
+  }
 
-  inline bool operator == (const PlatformInfo& other) {
+  inline bool operator==(const PlatformInfo& other)
+  {
     return format == other.format && arch == other.arch;
   }
 };
 
 class Platform {
-private:
+ private:
   Platform* next;
   static Platform* first;
-public:
+
+ public:
   PlatformInfo info;
 
-  inline Platform(PlatformInfo info):
-    next(first),
-    info(info)
+  inline Platform(PlatformInfo info) : next(first), info(info)
   {
     first = this;
   }
 
-  enum AccessFlags {
-    Writable = 1 << 0,
-    Executable = 1 << 1
-  };
+  enum AccessFlags { Writable = 1 << 0, Executable = 1 << 1 };
 
   virtual bool writeObject(OutputStream* out,
                            util::Slice<SymbolInfo> symbols,
@@ -161,9 +162,8 @@ public:
   static Platform* getPlatform(PlatformInfo info);
 };
 
-} // namespace tools
+}  // namespace tools
 
-} // namespace avian
+}  // namespace avian
 
 #endif
-
diff --git a/include/avian/util/abort.h b/include/avian/util/abort.h
index abe08eefc8..e65c9afb8a 100644
--- a/include/avian/util/abort.h
+++ b/include/avian/util/abort.h
@@ -19,7 +19,7 @@ namespace avian {
 namespace util {
 
 class Aborter {
-public:
+ public:
   virtual void NO_RETURN abort() = 0;
 };
 
@@ -28,15 +28,17 @@ inline Aborter* getAborter(Aborter* a)
   return a;
 }
 
-template<class T>
-inline void NO_RETURN abort(T t) {
+template <class T>
+inline void NO_RETURN abort(T t)
+{
   getAborter(t)->abort();
   ::abort();
 }
 
-template<class T>
-inline void expect(T t, bool v) {
-  if(UNLIKELY(!v)) {
+template <class T>
+inline void expect(T t, bool v)
+{
+  if (UNLIKELY(!v)) {
     abort(t);
   }
 }
@@ -51,7 +53,7 @@ inline void assertT(T t, bool v)
 }
 #endif
 
-} // namespace util
-} // namespace avian
+}  // namespace util
+}  // namespace avian
 
-#endif // AVIAN_UTIL_ABORT_H
+#endif  // AVIAN_UTIL_ABORT_H
diff --git a/include/avian/util/arg-parser.h b/include/avian/util/arg-parser.h
index 07145ce5a8..09b986c0eb 100644
--- a/include/avian/util/arg-parser.h
+++ b/include/avian/util/arg-parser.h
@@ -31,7 +31,7 @@ class ArgParser {
 };
 
 class Arg {
-public:
+ public:
   Arg* next;
   bool required;
   const char* name;
@@ -42,8 +42,7 @@ public:
   Arg(ArgParser& parser, bool required, const char* name, const char* desc);
 };
 
-
-} // namespace avian
-} // namespace util
+}  // namespace avian
+}  // namespace util
 
 #endif  // AVIAN_UTIL_ARG_PARSER_H
diff --git a/include/avian/util/list.h b/include/avian/util/list.h
index e621d30d77..2e58d97eeb 100644
--- a/include/avian/util/list.h
+++ b/include/avian/util/list.h
@@ -18,16 +18,17 @@ namespace util {
 
 template <class T>
 class List {
-public:
-  List(const T& item, List<T>* next):
-    item(item),
-    next(next) {}
+ public:
+  List(const T& item, List<T>* next) : item(item), next(next)
+  {
+  }
 
-  unsigned count() {
+  unsigned count()
+  {
     unsigned count = 0;
     List<T>* c = this;
     while (c) {
-      ++ count;
+      ++count;
       c = c->next;
     }
     return count;
diff --git a/include/avian/util/math.h b/include/avian/util/math.h
index bf66dbb922..611686826f 100644
--- a/include/avian/util/math.h
+++ b/include/avian/util/math.h
@@ -17,40 +17,51 @@
 namespace avian {
 namespace util {
 
-inline unsigned max(unsigned a, unsigned b) {
+inline unsigned max(unsigned a, unsigned b)
+{
   return (a > b ? a : b);
 }
 
-inline unsigned min(unsigned a, unsigned b) {
+inline unsigned min(unsigned a, unsigned b)
+{
   return (a < b ? a : b);
 }
 
-inline unsigned avg(unsigned a, unsigned b) {
+inline unsigned avg(unsigned a, unsigned b)
+{
   return (a + b) / 2;
 }
 
-inline unsigned ceilingDivide(unsigned n, unsigned d) {
+inline unsigned ceilingDivide(unsigned n, unsigned d)
+{
   return (n + d - 1) / d;
 }
 
-inline bool powerOfTwo(unsigned n) {
-  for (; n > 2; n >>= 1) if (n & 1) return false;
+inline bool powerOfTwo(unsigned n)
+{
+  for (; n > 2; n >>= 1)
+    if (n & 1)
+      return false;
   return true;
 }
 
-inline unsigned nextPowerOfTwo(unsigned n) {
+inline unsigned nextPowerOfTwo(unsigned n)
+{
   unsigned r = 1;
-  while (r < n) r <<= 1;
+  while (r < n)
+    r <<= 1;
   return r;
 }
 
-inline unsigned log(unsigned n) {
+inline unsigned log(unsigned n)
+{
   unsigned r = 0;
-  for (unsigned i = 1; i < n; ++r) i <<= 1;
+  for (unsigned i = 1; i < n; ++r)
+    i <<= 1;
   return r;
 }
-  
-} // namespace util
-} // namespace avian
 
-#endif // AVIAN_UTIL_MATH_H
+}  // namespace util
+}  // namespace avian
+
+#endif  // AVIAN_UTIL_MATH_H
diff --git a/include/avian/util/runtime-array.h b/include/avian/util/runtime-array.h
index d30633ae86..bbbe8854c6 100644
--- a/include/avian/util/runtime-array.h
+++ b/include/avian/util/runtime-array.h
@@ -16,25 +16,26 @@
 template <class T>
 class RuntimeArray {
  public:
-  RuntimeArray(unsigned size):
-    body(static_cast<T*>(malloc(size * sizeof(T))))
-  { }
+  RuntimeArray(unsigned size) : body(static_cast<T*>(malloc(size * sizeof(T))))
+  {
+  }
 
-  ~RuntimeArray() {
+  ~RuntimeArray()
+  {
     free(body);
   }
 
   T* body;
 };
 
-#  define RUNTIME_ARRAY(type, name, size) RuntimeArray<type> name(size);
-#  define RUNTIME_ARRAY_BODY(name) name.body
+#define RUNTIME_ARRAY(type, name, size) RuntimeArray<type> name(size);
+#define RUNTIME_ARRAY_BODY(name) name.body
 
-#else // not _MSC_VER
+#else  // not _MSC_VER
 
-#  define RUNTIME_ARRAY(type, name, size) type name##_body[size];
-#  define RUNTIME_ARRAY_BODY(name) name##_body
+#define RUNTIME_ARRAY(type, name, size) type name##_body[size];
+#define RUNTIME_ARRAY_BODY(name) name##_body
 
 #endif
 
-#endif // AVIAN_UTIL_RUNTIME_ARRAY_H
+#endif  // AVIAN_UTIL_RUNTIME_ARRAY_H
diff --git a/include/avian/util/stream.h b/include/avian/util/stream.h
index 9a347e2d4c..dd9d324518 100644
--- a/include/avian/util/stream.h
+++ b/include/avian/util/stream.h
@@ -22,19 +22,23 @@ class AbstractStream {
     virtual void handleError() = 0;
   };
 
-  AbstractStream(Client* client, unsigned size):
-    client(client), size(size), position_(0)
-  { }
+  AbstractStream(Client* client, unsigned size)
+      : client(client), size(size), position_(0)
+  {
+  }
 
-  unsigned position() {
+  unsigned position()
+  {
     return position_;
   }
 
-  void setPosition(unsigned p) {
+  void setPosition(unsigned p)
+  {
     position_ = p;
   }
 
-  void skip(unsigned size) {
+  void skip(unsigned size)
+  {
     if (size > this->size - position_) {
       client->handleError();
     } else {
@@ -42,7 +46,8 @@ class AbstractStream {
     }
   }
 
-  void read(uint8_t* dst, unsigned size) {
+  void read(uint8_t* dst, unsigned size)
+  {
     if (size > this->size - position_) {
       memset(dst, 0, size);
 
@@ -53,35 +58,41 @@ class AbstractStream {
     }
   }
 
-  uint8_t read1() {
+  uint8_t read1()
+  {
     uint8_t v;
     read(&v, 1);
     return v;
   }
 
-  uint16_t read2() {
+  uint16_t read2()
+  {
     uint16_t a = read1();
     uint16_t b = read1();
     return (a << 8) | b;
   }
 
-  uint32_t read4() {
+  uint32_t read4()
+  {
     uint32_t a = read2();
     uint32_t b = read2();
     return (a << 16) | b;
   }
 
-  uint64_t read8() {
+  uint64_t read8()
+  {
     uint64_t a = read4();
     uint64_t b = read4();
     return (a << 32) | b;
   }
 
-  uint32_t readFloat() {
+  uint32_t readFloat()
+  {
     return read4();
   }
 
-  uint64_t readDouble() {
+  uint64_t readDouble()
+  {
     return read8();
   }
 
@@ -94,20 +105,22 @@ class AbstractStream {
   unsigned position_;
 };
 
-class Stream: public AbstractStream {
+class Stream : public AbstractStream {
  public:
-  Stream(Client* client, const uint8_t* data, unsigned size):
-    AbstractStream(client, size), data(data)
-  { }
+  Stream(Client* client, const uint8_t* data, unsigned size)
+      : AbstractStream(client, size), data(data)
+  {
+  }
 
  private:
-  virtual void copy(uint8_t* dst, unsigned offset, unsigned size) {
+  virtual void copy(uint8_t* dst, unsigned offset, unsigned size)
+  {
     memcpy(dst, data + offset, size);
   }
 
   const uint8_t* data;
 };
 
-} // namespace vm
+}  // namespace vm
 
-#endif//STREAM_H
+#endif  // STREAM_H
diff --git a/include/avian/util/string.h b/include/avian/util/string.h
index aecce3ce9c..704dd9a5b1 100644
--- a/include/avian/util/string.h
+++ b/include/avian/util/string.h
@@ -17,38 +17,43 @@ namespace avian {
 namespace util {
 
 class String {
-public:
+ public:
   const char* text;
   size_t length;
 
-  String(const char* text):
-    text(text),
-    length(strlen(text)) {}
-  
-  inline String(const char* text, size_t length):
-    text(text),
-    length(length) {}
+  String(const char* text) : text(text), length(strlen(text))
+  {
+  }
+
+  inline String(const char* text, size_t length) : text(text), length(length)
+  {
+  }
 };
 
 class Tokenizer {
  public:
+  Tokenizer(const char* s, char delimiter)
+      : s(s), limit(0), delimiter(delimiter)
+  {
+  }
 
-  Tokenizer(const char* s, char delimiter):
-    s(s), limit(0), delimiter(delimiter)
-  { }
+  Tokenizer(String str, char delimiter)
+      : s(str.text), limit(str.text + str.length), delimiter(delimiter)
+  {
+  }
 
-  Tokenizer(String str, char delimiter):
-    s(str.text), limit(str.text + str.length), delimiter(delimiter)
-  { }
-
-  bool hasMore() {
-    while (s != limit and *s == delimiter) ++s;
+  bool hasMore()
+  {
+    while (s != limit and *s == delimiter)
+      ++s;
     return s != limit and *s != 0;
   }
 
-  String next() {
+  String next()
+  {
     const char* p = s;
-    while (s != limit and *s and *s != delimiter) ++s;
+    while (s != limit and *s and *s != delimiter)
+      ++s;
     return String(p, s - p);
   }
 
@@ -57,7 +62,7 @@ class Tokenizer {
   char delimiter;
 };
 
-} // namespace util
-} // namespace avain
+}  // namespace util
+}  // namespace avain
 
-#endif//AVIAN_UTIL_STRING_H
+#endif  // AVIAN_UTIL_STRING_H
diff --git a/src/android/stubs.cpp b/src/android/stubs.cpp
index 5d94b17292..7fe9362a3d 100644
--- a/src/android/stubs.cpp
+++ b/src/android/stubs.cpp
@@ -11,8 +11,7 @@ struct JniConstants {
   static void init(_JNIEnv* env);
 };
 
-void
-JniConstants::init(_JNIEnv*)
+void JniConstants::init(_JNIEnv*)
 {
   // ignore
 }
diff --git a/src/avian/alloc-vector.h b/src/avian/alloc-vector.h
index fce6f724b0..a859864d7c 100644
--- a/src/avian/alloc-vector.h
+++ b/src/avian/alloc-vector.h
@@ -33,13 +33,16 @@ class Vector {
         data(0, 0),
         position(0),
         minimumCapacity(minimumCapacity)
-  { }
+  {
+  }
 
-  ~Vector() {
+  ~Vector()
+  {
     dispose();
   }
 
-  void dispose() {
+  void dispose()
+  {
     if (data.items and minimumCapacity > 0) {
       allocator->free(data.items, data.count);
       data.items = 0;
@@ -95,27 +98,33 @@ class Vector {
     return r;
   }
 
-  void append(uint8_t v) {
+  void append(uint8_t v)
+  {
     append(&v, 1);
   }
 
-  void append2(uint16_t v) {
+  void append2(uint16_t v)
+  {
     append(&v, 2);
   }
 
-  void append4(uint32_t v) {
+  void append4(uint32_t v)
+  {
     append(&v, 4);
   }
 
-  void appendTargetAddress(target_uintptr_t v) {
+  void appendTargetAddress(target_uintptr_t v)
+  {
     append(&v, TargetBytesPerWord);
   }
 
-  void appendAddress(uintptr_t v) {
+  void appendAddress(uintptr_t v)
+  {
     append(&v, BytesPerWord);
   }
 
-  void appendAddress(void* v) {
+  void appendAddress(void* v)
+  {
     append(&v, BytesPerWord);
   }
 
@@ -127,25 +136,29 @@ class Vector {
 
   size_t get(size_t offset)
   {
-    uint8_t v; get(offset, &v, 1);
+    uint8_t v;
+    get(offset, &v, 1);
     return v;
   }
 
   size_t get2(size_t offset)
   {
-    uint16_t v; get(offset, &v, 2);
+    uint16_t v;
+    get(offset, &v, 2);
     return v;
   }
 
   size_t get4(size_t offset)
   {
-    uint32_t v; get(offset, &v, 4);
+    uint32_t v;
+    get(offset, &v, 4);
     return v;
   }
 
   uintptr_t getAddress(size_t offset)
   {
-    uintptr_t v; get(offset, &v, BytesPerWord);
+    uintptr_t v;
+    get(offset, &v, BytesPerWord);
     return v;
   }
 
@@ -168,6 +181,6 @@ class Vector {
   size_t minimumCapacity;
 };
 
-} // namespace vm
+}  // namespace vm
 
-#endif//VECTOR_H
+#endif  // VECTOR_H
diff --git a/src/avian/arch.h b/src/avian/arch.h
index 0cb12f9142..cf717b0369 100644
--- a/src/avian/arch.h
+++ b/src/avian/arch.h
@@ -12,39 +12,41 @@
 #define ARCH_H
 
 #ifdef _MSC_VER
-#  include "windows.h"
-#  pragma push_macro("assert")
-#  include "intrin.h"
-#  pragma pop_macro("assert")
-#  undef interface
+#include "windows.h"
+#pragma push_macro("assert")
+#include "intrin.h"
+#pragma pop_macro("assert")
+#undef interface
 #endif
 
 #include "avian/common.h"
 
-extern "C" void NO_RETURN
-vmJump(void* address, void* frame, void* stack, void* thread,
-       uintptr_t returnLow, uintptr_t returnHigh);
+extern "C" void NO_RETURN vmJump(void* address,
+                                 void* frame,
+                                 void* stack,
+                                 void* thread,
+                                 uintptr_t returnLow,
+                                 uintptr_t returnHigh);
 
 namespace vm {
 
-inline void
-compileTimeMemoryBarrier()
+inline void compileTimeMemoryBarrier()
 {
 #ifdef _MSC_VER
   _ReadWriteBarrier();
 #else
-  __asm__ __volatile__("": : :"memory");
+  __asm__ __volatile__("" : : : "memory");
 #endif
 }
 
-} // namespace vm
+}  // namespace vm
 
 #if (defined ARCH_x86_32) || (defined ARCH_x86_64)
-#  include "x86.h"
+#include "x86.h"
 #elif defined ARCH_arm
-#  include "arm.h"
+#include "arm.h"
 #else
-#  error unsupported architecture
+#error unsupported architecture
 #endif
 
-#endif//ARCH_H
+#endif  // ARCH_H
diff --git a/src/avian/arm.h b/src/avian/arm.h
index 37edcb7fb7..f3b86fd256 100644
--- a/src/avian/arm.h
+++ b/src/avian/arm.h
@@ -16,61 +16,62 @@
 #include <avian/util/runtime-array.h>
 
 #ifdef __APPLE__
-#  include "libkern/OSAtomic.h"
-#  include "libkern/OSCacheControl.h"
-#  include "mach/mach_types.h"
-#  include "mach/thread_act.h"
-#  include "mach/thread_status.h"
+#include "libkern/OSAtomic.h"
+#include "libkern/OSCacheControl.h"
+#include "mach/mach_types.h"
+#include "mach/thread_act.h"
+#include "mach/thread_status.h"
 
-#  define THREAD_STATE ARM_THREAD_STATE
-#  define THREAD_STATE_TYPE arm_thread_state_t
-#  define THREAD_STATE_COUNT ARM_THREAD_STATE_COUNT
+#define THREAD_STATE ARM_THREAD_STATE
+#define THREAD_STATE_TYPE arm_thread_state_t
+#define THREAD_STATE_COUNT ARM_THREAD_STATE_COUNT
 
-#  if __DARWIN_UNIX03 && defined(_STRUCT_ARM_EXCEPTION_STATE)
-#    define FIELD(x) __##x
-#  else
-#    define FIELD(x) x
-#  endif
-
-#  define THREAD_STATE_IP(state) ((state).FIELD(pc))
-#  define THREAD_STATE_STACK(state) ((state).FIELD(sp))
-#  define THREAD_STATE_THREAD(state) ((state).FIELD(r[8]))
-#  define THREAD_STATE_LINK(state) ((state).FIELD(lr))
-
-#  define IP_REGISTER(context) \
-  THREAD_STATE_IP(context->uc_mcontext->FIELD(ss))
-#  define STACK_REGISTER(context) \
-  THREAD_STATE_STACK(context->uc_mcontext->FIELD(ss))
-#  define THREAD_REGISTER(context) \
-  THREAD_STATE_THREAD(context->uc_mcontext->FIELD(ss))
-#  define LINK_REGISTER(context) \
-  THREAD_STATE_LINK(context->uc_mcontext->FIELD(ss))
-#elif (defined __QNX__)
-#  include "arm/smpxchg.h"
-#  include "sys/mman.h"
-
-#  define IP_REGISTER(context) (context->uc_mcontext.cpu.gpr[ARM_REG_PC])
-#  define STACK_REGISTER(context) (context->uc_mcontext.cpu.gpr[ARM_REG_SP])
-#  define THREAD_REGISTER(context) (context->uc_mcontext.cpu.gpr[ARM_REG_IP])
-#  define LINK_REGISTER(context) (context->uc_mcontext.cpu.gpr[ARM_REG_LR])
+#if __DARWIN_UNIX03 && defined(_STRUCT_ARM_EXCEPTION_STATE)
+#define FIELD(x) __##x
 #else
-#  define IP_REGISTER(context) (context->uc_mcontext.arm_pc)
-#  define STACK_REGISTER(context) (context->uc_mcontext.arm_sp)
-#  define THREAD_REGISTER(context) (context->uc_mcontext.arm_ip)
-#  define LINK_REGISTER(context) (context->uc_mcontext.arm_lr)
+#define FIELD(x) x
+#endif
+
+#define THREAD_STATE_IP(state) ((state).FIELD(pc))
+#define THREAD_STATE_STACK(state) ((state).FIELD(sp))
+#define THREAD_STATE_THREAD(state) ((state).FIELD(r[8]))
+#define THREAD_STATE_LINK(state) ((state).FIELD(lr))
+
+#define IP_REGISTER(context) THREAD_STATE_IP(context->uc_mcontext->FIELD(ss))
+#define STACK_REGISTER(context) \
+  THREAD_STATE_STACK(context->uc_mcontext->FIELD(ss))
+#define THREAD_REGISTER(context) \
+  THREAD_STATE_THREAD(context->uc_mcontext->FIELD(ss))
+#define LINK_REGISTER(context) \
+  THREAD_STATE_LINK(context->uc_mcontext->FIELD(ss))
+#elif(defined __QNX__)
+#include "arm/smpxchg.h"
+#include "sys/mman.h"
+
+#define IP_REGISTER(context) (context->uc_mcontext.cpu.gpr[ARM_REG_PC])
+#define STACK_REGISTER(context) (context->uc_mcontext.cpu.gpr[ARM_REG_SP])
+#define THREAD_REGISTER(context) (context->uc_mcontext.cpu.gpr[ARM_REG_IP])
+#define LINK_REGISTER(context) (context->uc_mcontext.cpu.gpr[ARM_REG_LR])
+#else
+#define IP_REGISTER(context) (context->uc_mcontext.arm_pc)
+#define STACK_REGISTER(context) (context->uc_mcontext.arm_sp)
+#define THREAD_REGISTER(context) (context->uc_mcontext.arm_ip)
+#define LINK_REGISTER(context) (context->uc_mcontext.arm_lr)
 #endif
 
 #define VA_LIST(x) (&(x))
 
-extern "C" uint64_t
-vmNativeCall(void* function, unsigned stackTotal, void* memoryTable,
-             unsigned memoryCount, void* gprTable, void* vfpTable,
-             unsigned returnType);
+extern "C" uint64_t vmNativeCall(void* function,
+                                 unsigned stackTotal,
+                                 void* memoryTable,
+                                 unsigned memoryCount,
+                                 void* gprTable,
+                                 void* vfpTable,
+                                 unsigned returnType);
 
 namespace vm {
 
-inline void
-trap()
+inline void trap()
 {
 #ifdef _MSC_VER
   __debugbreak();
@@ -86,23 +87,21 @@ trap()
 // performant choice.
 
 #ifndef _MSC_VER
-inline void
-memoryBarrier()
+inline void memoryBarrier()
 {
 #ifdef __APPLE__
   OSMemoryBarrier();
-#elif (__GNUC__ >= 4) && (__GNUC_MINOR__ >= 1)
+#elif(__GNUC__ >= 4) && (__GNUC_MINOR__ >= 1)
   return __sync_synchronize();
-#elif (! defined AVIAN_ASSUME_ARMV6)
-  __asm__ __volatile__ ("dmb" : : : "memory");
+#elif(!defined AVIAN_ASSUME_ARMV6)
+  __asm__ __volatile__("dmb" : : : "memory");
 #else
-  __asm__ __volatile__ ("" : : : "memory");
+  __asm__ __volatile__("" : : : "memory");
 #endif
 }
 #endif
 
-inline void
-storeStoreMemoryBarrier()
+inline void storeStoreMemoryBarrier()
 {
 #ifdef _MSC_VER
   _ReadWriteBarrier();
@@ -111,8 +110,7 @@ storeStoreMemoryBarrier()
 #endif
 }
 
-inline void
-storeLoadMemoryBarrier()
+inline void storeLoadMemoryBarrier()
 {
 #ifdef _MSC_VER
   MemoryBarrier();
@@ -121,8 +119,7 @@ storeLoadMemoryBarrier()
 #endif
 }
 
-inline void
-loadMemoryBarrier()
+inline void loadMemoryBarrier()
 {
 #ifdef _MSC_VER
   _ReadWriteBarrier();
@@ -135,52 +132,54 @@ loadMemoryBarrier()
 
 #if defined(__ANDROID__)
 // http://code.google.com/p/android/issues/detail?id=1803
-extern "C" void __clear_cache (void *beg __attribute__((__unused__)), void *end __attribute__((__unused__)));
+extern "C" void __clear_cache(void* beg __attribute__((__unused__)),
+                              void* end __attribute__((__unused__)));
 #endif
-inline void
-syncInstructionCache(const void* start, unsigned size)
+inline void syncInstructionCache(const void* start, unsigned size)
 {
 #ifdef __APPLE__
   sys_icache_invalidate(const_cast<void*>(start), size);
-#elif (defined __QNX__)
+#elif(defined __QNX__)
   msync(const_cast<void*>(start), size, MS_INVALIDATE_ICACHE);
 #else
-  __clear_cache
-    (const_cast<void*>(start),
-     const_cast<uint8_t*>(static_cast<const uint8_t*>(start) + size));
+  __clear_cache(
+      const_cast<void*>(start),
+      const_cast<uint8_t*>(static_cast<const uint8_t*>(start) + size));
 #endif
 }
 
-#endif // AVIAN_AOT_ONLY
+#endif  // AVIAN_AOT_ONLY
 
 #ifndef __APPLE__
-typedef int (__kernel_cmpxchg_t)(int oldval, int newval, int *ptr);
-#  define __kernel_cmpxchg (*(__kernel_cmpxchg_t *)0xffff0fc0)
+typedef int(__kernel_cmpxchg_t)(int oldval, int newval, int* ptr);
+#define __kernel_cmpxchg (*(__kernel_cmpxchg_t*)0xffff0fc0)
 #endif
 
-inline bool
-atomicCompareAndSwap32(uint32_t* p, uint32_t old, uint32_t new_)
+inline bool atomicCompareAndSwap32(uint32_t* p, uint32_t old, uint32_t new_)
 {
 #ifdef __APPLE__
-  return OSAtomicCompareAndSwap32Barrier(old, new_, reinterpret_cast<int32_t*>(p));
-#elif (defined __QNX__)
+  return OSAtomicCompareAndSwap32Barrier(
+      old, new_, reinterpret_cast<int32_t*>(p));
+#elif(defined __QNX__)
   return old == _smp_cmpxchg(p, old, new_);
 #else
-  int r = __kernel_cmpxchg(static_cast<int>(old), static_cast<int>(new_), reinterpret_cast<int*>(p));
+  int r = __kernel_cmpxchg(
+      static_cast<int>(old), static_cast<int>(new_), reinterpret_cast<int*>(p));
   return (!r ? true : false);
 #endif
 }
 
-inline bool
-atomicCompareAndSwap(uintptr_t* p, uintptr_t old, uintptr_t new_)
+inline bool atomicCompareAndSwap(uintptr_t* p, uintptr_t old, uintptr_t new_)
 {
   return atomicCompareAndSwap32(reinterpret_cast<uint32_t*>(p), old, new_);
 }
 
-inline uint64_t
-dynamicCall(void* function, uintptr_t* arguments, uint8_t* argumentTypes,
-            unsigned argumentCount, unsigned argumentsSize UNUSED,
-            unsigned returnType)
+inline uint64_t dynamicCall(void* function,
+                            uintptr_t* arguments,
+                            uint8_t* argumentTypes,
+                            unsigned argumentCount,
+                            unsigned argumentsSize UNUSED,
+                            unsigned returnType)
 {
 #ifdef __APPLE__
   const unsigned Alignment = 1;
@@ -197,34 +196,37 @@ dynamicCall(void* function, uintptr_t* arguments, uint8_t* argumentTypes,
   unsigned vfpIndex = 0;
   unsigned vfpBackfillIndex UNUSED = 0;
 
-  RUNTIME_ARRAY(uintptr_t, stack, (argumentCount * 8) / BytesPerWord); // is > argumentSize to account for padding
+  RUNTIME_ARRAY(uintptr_t,
+                stack,
+                (argumentCount * 8)
+                / BytesPerWord);  // is > argumentSize to account for padding
   unsigned stackIndex = 0;
 
   unsigned ai = 0;
-  for (unsigned ati = 0; ati < argumentCount; ++ ati) {
+  for (unsigned ati = 0; ati < argumentCount; ++ati) {
     switch (argumentTypes[ati]) {
     case DOUBLE_TYPE:
 #if defined(__ARM_PCS_VFP)
-      {
-        if (vfpIndex + Alignment <= VfpCount) {
-          if (vfpIndex % Alignment) {
-            vfpBackfillIndex = vfpIndex;
-            ++ vfpIndex;
-          }
-          
-          memcpy(vfpTable + vfpIndex, arguments + ai, 8);
-          vfpIndex += 8 / BytesPerWord;
-        } else {
-          vfpIndex = VfpCount;
-          if (stackIndex % Alignment) {
-            ++ stackIndex;
-          }
-
-          memcpy(RUNTIME_ARRAY_BODY(stack) + stackIndex, arguments + ai, 8);
-          stackIndex += 8 / BytesPerWord;
+    {
+      if (vfpIndex + Alignment <= VfpCount) {
+        if (vfpIndex % Alignment) {
+          vfpBackfillIndex = vfpIndex;
+          ++vfpIndex;
         }
-        ai += 8 / BytesPerWord;
-      } break;
+
+        memcpy(vfpTable + vfpIndex, arguments + ai, 8);
+        vfpIndex += 8 / BytesPerWord;
+      } else {
+        vfpIndex = VfpCount;
+        if (stackIndex % Alignment) {
+          ++stackIndex;
+        }
+
+        memcpy(RUNTIME_ARRAY_BODY(stack) + stackIndex, arguments + ai, 8);
+        stackIndex += 8 / BytesPerWord;
+      }
+      ai += 8 / BytesPerWord;
+    } break;
 
     case FLOAT_TYPE:
       if (vfpBackfillIndex) {
@@ -235,26 +237,24 @@ dynamicCall(void* function, uintptr_t* arguments, uint8_t* argumentTypes,
       } else {
         RUNTIME_ARRAY_BODY(stack)[stackIndex++] = arguments[ai];
       }
-      ++ ai;
+      ++ai;
       break;
 #endif
     case INT64_TYPE: {
-      if (gprIndex + Alignment <= GprCount) { // pass argument in register(s)
-        if (Alignment == 1
-            and BytesPerWord < 8
-            and gprIndex + Alignment == GprCount)
-        {
+      if (gprIndex + Alignment <= GprCount) {  // pass argument in register(s)
+        if (Alignment == 1 and BytesPerWord < 8
+            and gprIndex + Alignment == GprCount) {
           gprTable[gprIndex++] = arguments[ai];
           RUNTIME_ARRAY_BODY(stack)[stackIndex++] = arguments[ai + 1];
         } else {
           if (gprIndex % Alignment) {
             ++gprIndex;
           }
-          
+
           memcpy(gprTable + gprIndex, arguments + ai, 8);
           gprIndex += 8 / BytesPerWord;
         }
-      } else {                                // pass argument on stack
+      } else {  // pass argument on stack
         gprIndex = GprCount;
         if (stackIndex % Alignment) {
           ++stackIndex;
@@ -272,27 +272,30 @@ dynamicCall(void* function, uintptr_t* arguments, uint8_t* argumentTypes,
       } else {
         RUNTIME_ARRAY_BODY(stack)[stackIndex++] = arguments[ai];
       }
-      ++ ai;
+      ++ai;
     } break;
     }
   }
 
-  if (gprIndex < GprCount) { // pad since assembly loads all GPRs
-    memset(gprTable + gprIndex, 0, (GprCount-gprIndex)*4);
+  if (gprIndex < GprCount) {  // pad since assembly loads all GPRs
+    memset(gprTable + gprIndex, 0, (GprCount - gprIndex) * 4);
     gprIndex = GprCount;
   }
   if (vfpIndex < VfpCount) {
-    memset(vfpTable + vfpIndex, 0, (VfpCount-vfpIndex)*4);
+    memset(vfpTable + vfpIndex, 0, (VfpCount - vfpIndex) * 4);
     vfpIndex = VfpCount;
   }
 
-  unsigned stackSize = stackIndex*BytesPerWord + ((stackIndex & 1) << 2);
-  return vmNativeCall
-    (function, stackSize, RUNTIME_ARRAY_BODY(stack), stackIndex * BytesPerWord,
-     (gprIndex ? gprTable : 0),
-     (vfpIndex ? vfpTable : 0), returnType);
+  unsigned stackSize = stackIndex * BytesPerWord + ((stackIndex & 1) << 2);
+  return vmNativeCall(function,
+                      stackSize,
+                      RUNTIME_ARRAY_BODY(stack),
+                      stackIndex * BytesPerWord,
+                      (gprIndex ? gprTable : 0),
+                      (vfpIndex ? vfpTable : 0),
+                      returnType);
 }
 
-} // namespace vm
+}  // namespace vm
 
-#endif // ARM_H
+#endif  // ARM_H
diff --git a/src/avian/bootimage.h b/src/avian/bootimage.h
index 1505917f4d..51796918d9 100644
--- a/src/avian/bootimage.h
+++ b/src/avian/bootimage.h
@@ -24,13 +24,14 @@ class BootImage {
  public:
   class Thunk {
    public:
-    Thunk():
-      start(0), frameSavedOffset(0), length(0)
-    { }
+    Thunk() : start(0), frameSavedOffset(0), length(0)
+    {
+    }
 
-    Thunk(uint32_t start, uint32_t frameSavedOffset, uint32_t length):
-      start(start), frameSavedOffset(frameSavedOffset), length(length)
-    { }
+    Thunk(uint32_t start, uint32_t frameSavedOffset, uint32_t length)
+        : start(start), frameSavedOffset(frameSavedOffset), length(length)
+    {
+    }
 
     uint32_t start;
     uint32_t frameSavedOffset;
@@ -72,6 +73,6 @@ class OffsetResolver {
 #undef LABEL
 #undef NAME
 
-} // namespace vm
+}  // namespace vm
 
-#endif//BOOTIMAGE_H
+#endif  // BOOTIMAGE_H
diff --git a/src/avian/classpath-common.h b/src/avian/classpath-common.h
index 6593431ef8..b877ae2425 100644
--- a/src/avian/classpath-common.h
+++ b/src/avian/classpath-common.h
@@ -18,16 +18,16 @@ using namespace avian::util;
 
 namespace vm {
 
-object
-getTrace(Thread* t, unsigned skipCount)
+object getTrace(Thread* t, unsigned skipCount)
 {
-  class Visitor: public Processor::StackVisitor {
+  class Visitor : public Processor::StackVisitor {
    public:
-    Visitor(Thread* t, int skipCount):
-      t(t), trace(0), skipCount(skipCount)
-    { }
+    Visitor(Thread* t, int skipCount) : t(t), trace(0), skipCount(skipCount)
+    {
+    }
 
-    virtual bool visit(Processor::StackWalker* walker) {
+    virtual bool visit(Processor::StackWalker* walker)
+    {
       if (skipCount == 0) {
         GcMethod* method = walker->method();
         if (isAssignableFrom(t, type(t, GcThrowable::Type), method->class_())
@@ -39,7 +39,7 @@ getTrace(Thread* t, unsigned skipCount)
           return false;
         }
       } else {
-        -- skipCount;
+        --skipCount;
         return true;
       }
     }
@@ -51,7 +51,8 @@ getTrace(Thread* t, unsigned skipCount)
 
   t->m->processor->walkStack(t, &v);
 
-  if (v.trace == 0) v.trace = makeObjectArray(t, 0);
+  if (v.trace == 0)
+    v.trace = makeObjectArray(t, 0);
 
   return v.trace;
 }
@@ -63,23 +64,24 @@ bool compatibleArrayTypes(Thread* t UNUSED, GcClass* a, GcClass* b)
                              or (b->vmFlags() & PrimitiveFlag))));
 }
 
-void
-arrayCopy(Thread* t, object src, int32_t srcOffset, object dst,
-          int32_t dstOffset, int32_t length)
+void arrayCopy(Thread* t,
+               object src,
+               int32_t srcOffset,
+               object dst,
+               int32_t dstOffset,
+               int32_t length)
 {
   if (LIKELY(src and dst)) {
-    if (LIKELY(compatibleArrayTypes
-               (t, objectClass(t, src), objectClass(t, dst))))
-    {
+    if (LIKELY(compatibleArrayTypes(
+            t, objectClass(t, src), objectClass(t, dst)))) {
       unsigned elementSize = objectClass(t, src)->arrayElementSize();
 
       if (LIKELY(elementSize)) {
         intptr_t sl = fieldAtOffset<uintptr_t>(src, BytesPerWord);
         intptr_t dl = fieldAtOffset<uintptr_t>(dst, BytesPerWord);
         if (LIKELY(length > 0)) {
-          if (LIKELY(srcOffset >= 0 and srcOffset + length <= sl and
-                     dstOffset >= 0 and dstOffset + length <= dl))
-          {
+          if (LIKELY(srcOffset >= 0 and srcOffset + length <= sl
+                     and dstOffset >= 0 and dstOffset + length <= dl)) {
             uint8_t* sbody = &fieldAtOffset<uint8_t>(src, ArrayBody);
             uint8_t* dbody = &fieldAtOffset<uint8_t>(dst, ArrayBody);
             if (src == dst) {
@@ -113,8 +115,7 @@ arrayCopy(Thread* t, object src, int32_t srcOffset, object dst,
   throwNew(t, GcArrayStoreException::Type);
 }
 
-void
-runOnLoadIfFound(Thread* t, System::Library* library)
+void runOnLoadIfFound(Thread* t, System::Library* library)
 {
   void* p = library->resolve("JNI_OnLoad");
 
@@ -128,14 +129,13 @@ runOnLoadIfFound(Thread* t, System::Library* library)
 #endif
 
   if (p) {
-    jint (JNICALL * JNI_OnLoad)(Machine*, void*);
+    jint(JNICALL * JNI_OnLoad)(Machine*, void*);
     memcpy(&JNI_OnLoad, &p, sizeof(void*));
     JNI_OnLoad(t->m, 0);
   }
 }
 
-System::Library*
-loadLibrary(Thread* t, const char* name)
+System::Library* loadLibrary(Thread* t, const char* name)
 {
   ACQUIRE(t, t->m->classLock);
 
@@ -157,9 +157,12 @@ loadLibrary(Thread* t, const char* name)
   }
 }
 
-System::Library*
-loadLibrary(Thread* t, const char* path, const char* name, bool mapName,
-            bool runOnLoad, bool throw_ = true)
+System::Library* loadLibrary(Thread* t,
+                             const char* path,
+                             const char* name,
+                             bool mapName,
+                             bool runOnLoad,
+                             bool throw_ = true)
 {
   ACQUIRE(t, t->m->classLock);
 
@@ -171,8 +174,7 @@ loadLibrary(Thread* t, const char* path, const char* name, bool mapName,
       const char* s = builtins;
       while (*s) {
         if (::strncmp(s, name, nameLength) == 0
-            and (s[nameLength] == ',' or s[nameLength] == 0))
-        {
+            and (s[nameLength] == ',' or s[nameLength] == 0)) {
           // library is built in to this executable
           if (runOnLoad and not t->m->triedBuiltinOnLoad) {
             t->m->triedBuiltinOnLoad = true;
@@ -182,8 +184,10 @@ loadLibrary(Thread* t, const char* path, const char* name, bool mapName,
           }
           return t->m->libraries;
         } else {
-          while (*s and *s != ',') ++ s;
-          if (*s) ++ s;
+          while (*s and *s != ',')
+            ++s;
+          if (*s)
+            ++s;
         }
       }
     }
@@ -192,8 +196,7 @@ loadLibrary(Thread* t, const char* path, const char* name, bool mapName,
     const char* suffix = t->m->system->librarySuffix();
     unsigned mappedNameLength = nameLength + strlen(prefix) + strlen(suffix);
 
-    mappedName = static_cast<char*>
-      (t->m->heap->allocate(mappedNameLength + 1));
+    mappedName = static_cast<char*>(t->m->heap->allocate(mappedNameLength + 1));
 
     snprintf(mappedName, mappedNameLength + 1, "%s%s%s", prefix, name, suffix);
 
@@ -203,25 +206,28 @@ loadLibrary(Thread* t, const char* path, const char* name, bool mapName,
     mappedName = 0;
   }
 
-  THREAD_RESOURCE2
-    (t, char*, mappedName, unsigned, nameLength, if (mappedName) {
-      t->m->heap->free(mappedName, nameLength + 1);
-    });
+  THREAD_RESOURCE2(t, char*, mappedName, unsigned, nameLength, if (mappedName) {
+    t->m->heap->free(mappedName, nameLength + 1);
+  });
 
   System::Library* lib = 0;
   for (Tokenizer tokenizer(path, t->m->system->pathSeparator());
-       tokenizer.hasMore();)
-  {
+       tokenizer.hasMore();) {
     String token(tokenizer.next());
 
     unsigned fullNameLength = token.length + 1 + nameLength;
     THREAD_RUNTIME_ARRAY(t, char, fullName, fullNameLength + 1);
 
-    snprintf(RUNTIME_ARRAY_BODY(fullName), fullNameLength + 1,
-             "%.*s/%s", token.length, token.text, name);
+    snprintf(RUNTIME_ARRAY_BODY(fullName),
+             fullNameLength + 1,
+             "%.*s/%s",
+             token.length,
+             token.text,
+             name);
 
     lib = loadLibrary(t, RUNTIME_ARRAY_BODY(fullName));
-    if (lib) break;
+    if (lib)
+      break;
   }
 
   if (lib == 0) {
@@ -243,8 +249,7 @@ loadLibrary(Thread* t, const char* path, const char* name, bool mapName,
   return lib;
 }
 
-object
-clone(Thread* t, object o)
+object clone(Thread* t, object o)
 {
   PROTECT(t, o);
 
@@ -396,10 +401,10 @@ GcPair* resolveParameterTypes(Thread* t,
     switch (spec->body()[offset]) {
     case 'L': {
       unsigned start = offset;
-      ++ offset;
+      ++offset;
       while (spec->body()[offset] != ';')
         ++offset;
-      ++ offset;
+      ++offset;
 
       GcClass* type
           = resolveClassBySpec(t,
@@ -409,7 +414,7 @@ GcPair* resolveParameterTypes(Thread* t,
 
       list = makePair(t, type, list);
 
-      ++ count;
+      ++count;
     } break;
 
     case '[': {
@@ -418,14 +423,14 @@ GcPair* resolveParameterTypes(Thread* t,
         ++offset;
       switch (spec->body()[offset]) {
       case 'L':
-        ++ offset;
+        ++offset;
         while (spec->body()[offset] != ';')
           ++offset;
-        ++ offset;
+        ++offset;
         break;
 
       default:
-        ++ offset;
+        ++offset;
         break;
       }
 
@@ -436,13 +441,13 @@ GcPair* resolveParameterTypes(Thread* t,
                                offset - start);
 
       list = makePair(t, type, list);
-      ++ count;
+      ++count;
     } break;
 
     default:
       list = makePair(t, primitiveClass(t, spec->body()[offset]), list);
-      ++ offset;
-      ++ count;
+      ++offset;
+      ++count;
       break;
     }
   }
@@ -570,7 +575,7 @@ object invoke(Thread* t, GcMethod* method, object instance, object args)
         objectType = true;
         unsigned nameLength;
         if (*p == 'L') {
-          ++ p;
+          ++p;
           nameLength = it.s - p;
         } else {
           nameLength = (it.s - p) + 1;
@@ -588,9 +593,10 @@ object invoke(Thread* t, GcMethod* method, object instance, object args)
 
       object arg = objectArrayBody(t, args, i++);
       if ((arg == 0 and (not objectType))
-          or (arg and (not instanceOf(t, type, arg))))
-      {
-        // fprintf(stderr, "%s is not a %s\n", arg ? &byteArrayBody(t, className(t, objectClass(t, arg)), 0) : reinterpret_cast<const int8_t*>("<null>"), &byteArrayBody(t, className(t, type), 0));
+          or (arg and (not instanceOf(t, type, arg)))) {
+        // fprintf(stderr, "%s is not a %s\n", arg ? &byteArrayBody(t,
+        // className(t, objectClass(t, arg)), 0) : reinterpret_cast<const
+        // int8_t*>("<null>"), &byteArrayBody(t, className(t, type), 0));
 
         throwNew(t, GcIllegalArgumentException::Type);
       }
@@ -602,14 +608,14 @@ object invoke(Thread* t, GcMethod* method, object instance, object args)
   unsigned returnCode = method->returnCode();
 
   THREAD_RESOURCE0(t, {
-      if (t->exception) {
-        t->exception = makeThrowable(
-            t, GcInvocationTargetException::Type, 0, 0, t->exception);
+    if (t->exception) {
+      t->exception = makeThrowable(
+          t, GcInvocationTargetException::Type, 0, 0, t->exception);
 
-        t->exception->as<GcInvocationTargetException>(t)
-            ->setTarget(t, t->exception->cause());
-      }
-    });
+      t->exception->as<GcInvocationTargetException>(t)
+          ->setTarget(t, t->exception->cause());
+    }
+  });
 
   object result;
   if (args) {
@@ -664,8 +670,7 @@ void intercept(Thread* t,
   }
 }
 
-Finder*
-getFinder(Thread* t, const char* name, unsigned nameLength)
+Finder* getFinder(Thread* t, const char* name, unsigned nameLength)
 {
   ACQUIRE(t, t->m->referenceLock);
 
@@ -718,7 +723,7 @@ object getDeclaredClasses(Thread* t, GcClass* c, bool publicOnly)
         GcByteArray* outer = reference->outer();
         if (outer and byteArrayEqual(t, outer, c->name())
             and ((not publicOnly) or (reference->flags() & ACC_PUBLIC))) {
-          ++ count;
+          ++count;
         }
       }
 
@@ -734,7 +739,7 @@ object getDeclaredClasses(Thread* t, GcClass* c, bool publicOnly)
           object inner
               = getJClass(t, resolveClass(t, c->loader(), reference->inner()));
 
-          -- count;
+          --count;
           reinterpret_cast<GcArray*>(result)->setBodyElement(t, count, inner);
         }
       }
@@ -787,6 +792,6 @@ unsigned classModifiers(Thread* t, GcClass* c)
   return c->flags();
 }
 
-} // namespace vm
+}  // namespace vm
 
-#endif//CLASSPATH_COMMON_H
+#endif  // CLASSPATH_COMMON_H
diff --git a/src/avian/common.h b/src/avian/common.h
index 774b5d1965..d3d5c98adb 100644
--- a/src/avian/common.h
+++ b/src/avian/common.h
@@ -12,7 +12,7 @@
 #define AVIAN_COMMON_H
 
 #ifndef __STDC_CONSTANT_MACROS
-#  define __STDC_CONSTANT_MACROS
+#define __STDC_CONSTANT_MACROS
 #endif
 
 #include <new>
@@ -31,11 +31,11 @@
 #include <stdint.h>
 
 #ifdef linux
-#  undef linux
+#undef linux
 #endif
 
 // don't complain about using 'this' in member initializers:
-#  pragma warning(disable:4355)
+#pragma warning(disable : 4355)
 
 #define strncasecmp _strnicmp
 
@@ -43,192 +43,195 @@
 #define FP_INFINITE 1
 #define FP_UNDEF 2
 
-inline int fpclassify(double d) {
-
-	switch(_fpclass(d)) {
-		case _FPCLASS_SNAN:
-		case _FPCLASS_QNAN:
-			return FP_NAN;
-		case _FPCLASS_PINF:
-		case _FPCLASS_NINF:
-			return FP_INFINITE;
-	}
-	return FP_UNDEF;
+inline int fpclassify(double d)
+{
+  switch (_fpclass(d)) {
+  case _FPCLASS_SNAN:
+  case _FPCLASS_QNAN:
+    return FP_NAN;
+  case _FPCLASS_PINF:
+  case _FPCLASS_NINF:
+    return FP_INFINITE;
+  }
+  return FP_UNDEF;
 }
 
-inline int signbit(double d) {
-	return _copysign(1.0, d) < 0;
+inline int signbit(double d)
+{
+  return _copysign(1.0, d) < 0;
 }
 
-#  define not !
-#  define or ||
-#  define and &&
-#  define xor ^
+#define not!
+#define or ||
+#define and &&
+#define xor ^
 
-#  define LIKELY(v) v
-#  define UNLIKELY(v) v
+#define LIKELY(v) v
+#define UNLIKELY(v) v
 
-#  define UNUSED
+#define UNUSED
 
-#  define NO_RETURN __declspec(noreturn)
+#define NO_RETURN __declspec(noreturn)
 
-#  define PACKED
+#define PACKED
 
-#  define PLATFORM_WINDOWS
+#define PLATFORM_WINDOWS
 
-#  ifdef _M_IX86
+#ifdef _M_IX86
 typedef int32_t intptr_t;
 typedef uint32_t uintptr_t;
-#    define ARCH_x86_32
-#    define BYTES_PER_WORD 4
-#  elif defined _M_X64
+#define ARCH_x86_32
+#define BYTES_PER_WORD 4
+#elif defined _M_X64
 typedef int64_t intptr_t;
 typedef uint64_t uintptr_t;
-#    define ARCH_x86_64
-#    define BYTES_PER_WORD 8
-#  elif defined _M_ARM_FP
+#define ARCH_x86_64
+#define BYTES_PER_WORD 8
+#elif defined _M_ARM_FP
 typedef int32_t intptr_t;
 typedef uint32_t uintptr_t;
-#    define ARCH_arm
-#    define BYTES_PER_WORD 4
-#  else
-#    error "unsupported architecture"
-#  endif
+#define ARCH_arm
+#define BYTES_PER_WORD 4
+#else
+#error "unsupported architecture"
+#endif
 
 namespace vm {
 
 typedef intptr_t intptr_alias_t;
 
-} // namespace vm
+}  // namespace vm
 
-#else // not _MSC_VER
+#else  // not _MSC_VER
 
-#  include <stdint.h>
+#include <stdint.h>
 
-#  define BYTES_PER_WORD __SIZEOF_POINTER__
+#define BYTES_PER_WORD __SIZEOF_POINTER__
 
-#  define LIKELY(v) __builtin_expect((v) != 0, true)
-#  define UNLIKELY(v) __builtin_expect((v) != 0, false)
+#define LIKELY(v) __builtin_expect((v) != 0, true)
+#define UNLIKELY(v) __builtin_expect((v) != 0, false)
 
-#  define UNUSED __attribute__((unused))
+#define UNUSED __attribute__((unused))
 
-#  define NO_RETURN __attribute__((noreturn))
+#define NO_RETURN __attribute__((noreturn))
 
-#  define PACKED __attribute__((packed))
+#define PACKED __attribute__((packed))
 
-#  ifdef __MINGW32__
-#    define PLATFORM_WINDOWS
-#  endif
+#ifdef __MINGW32__
+#define PLATFORM_WINDOWS
+#endif
 
-#  ifdef __i386__
-#    define ARCH_x86_32
-#  elif defined __x86_64__
-#    define ARCH_x86_64
-#  elif defined __arm__
-#    define ARCH_arm
-#  else
-#    error "unsupported architecture"
-#  endif
+#ifdef __i386__
+#define ARCH_x86_32
+#elif defined __x86_64__
+#define ARCH_x86_64
+#elif defined __arm__
+#define ARCH_arm
+#else
+#error "unsupported architecture"
+#endif
 
 namespace vm {
 
 typedef intptr_t __attribute__((__may_alias__)) intptr_alias_t;
 
-} // namespace vm
+}  // namespace vm
 
-#endif // not _MSC_VER
+#endif  // not _MSC_VER
 
 #ifdef PLATFORM_WINDOWS
-#  define AVIAN_EXPORT __declspec(dllexport)
-#  define PATH_SEPARATOR ';'
-#else // not PLATFORM_WINDOWS
-#  define AVIAN_EXPORT __attribute__ ((visibility("default"))) \
-  __attribute__ ((used))
-#  define PATH_SEPARATOR ':'
-#endif // not PLATFORM_WINDOWS
+#define AVIAN_EXPORT __declspec(dllexport)
+#define PATH_SEPARATOR ';'
+#else  // not PLATFORM_WINDOWS
+#define AVIAN_EXPORT \
+  __attribute__((visibility("default"))) __attribute__((used))
+#define PATH_SEPARATOR ':'
+#endif  // not PLATFORM_WINDOWS
 
 #if (defined ARCH_x86_32) || (defined ARCH_arm)
-#  define LD "ld"
-#  if (defined _MSC_VER) || ((defined __MINGW32__) && __GNUC__ >= 4)
-#    define LLD "I64d"
-#  else
-#    define LLD "lld"
-#  endif
-#  ifdef __APPLE__
-#    define ULD "lu"
-#    define LX "lx"
-#  else
-#    define LX "x"
-#    define ULD "u"
-#  endif
-#elif defined ARCH_x86_64
-#  define LD "ld"
-#  define LX "lx"
-#  if (defined _MSC_VER) || (defined __MINGW32__)
-#    define LLD "I64d"
-#    define ULD "I64x"
-#  else
-#    ifdef __APPLE__
-#      define LLD "lld"
-#    else
-#      define LLD "ld"
-#    endif
-#    define ULD "lu"
-#  endif
+#define LD "ld"
+#if (defined _MSC_VER) || ((defined __MINGW32__) && __GNUC__ >= 4)
+#define LLD "I64d"
 #else
-#  error "Unsupported architecture"
+#define LLD "lld"
+#endif
+#ifdef __APPLE__
+#define ULD "lu"
+#define LX "lx"
+#else
+#define LX "x"
+#define ULD "u"
+#endif
+#elif defined ARCH_x86_64
+#define LD "ld"
+#define LX "lx"
+#if (defined _MSC_VER) || (defined __MINGW32__)
+#define LLD "I64d"
+#define ULD "I64x"
+#else
+#ifdef __APPLE__
+#define LLD "lld"
+#else
+#define LLD "ld"
+#endif
+#define ULD "lu"
+#endif
+#else
+#error "Unsupported architecture"
 #endif
 
 #ifdef PLATFORM_WINDOWS
-#  define SO_PREFIX ""
+#define SO_PREFIX ""
 #else
-#  define SO_PREFIX "lib"
+#define SO_PREFIX "lib"
 #endif
 
 #ifdef __APPLE__
-#  define SO_SUFFIX ".dylib"
+#define SO_SUFFIX ".dylib"
 #elif defined PLATFORM_WINDOWS
-#  define SO_SUFFIX ".dll"
+#define SO_SUFFIX ".dll"
 #else
-#  define SO_SUFFIX ".so"
+#define SO_SUFFIX ".so"
 #endif
 
 #define MACRO_XY(X, Y) X##Y
 #define MACRO_MakeNameXY(FX, LINE) MACRO_XY(FX, LINE)
 #define MAKE_NAME(FX) MACRO_MakeNameXY(FX, __LINE__)
 
-#define RESOURCE(type, name, release)                                   \
-  class MAKE_NAME(Resource_) {                                          \
-  public:                                                               \
-    MAKE_NAME(Resource_)(type name): name(name) { }                     \
-    ~MAKE_NAME(Resource_)() { release; }                                \
-                                                                        \
-  private:                                                              \
-    type name;                                                          \
+#define RESOURCE(type, name, release)            \
+  class MAKE_NAME(Resource_) {                   \
+   public:                                       \
+    MAKE_NAME(Resource_)(type name) : name(name) \
+    {                                            \
+    }                                            \
+    ~MAKE_NAME(Resource_)()                      \
+    {                                            \
+      release;                                   \
+    }                                            \
+                                                 \
+   private:                                      \
+    type name;                                   \
   } MAKE_NAME(resource_)(name);
 
 #ifdef _MSC_VER
-#  pragma warning( disable : 4291 )
+#pragma warning(disable : 4291)
 #endif
 
 namespace vm {
 
-inline intptr_alias_t&
-alias(void* p, unsigned offset)
+inline intptr_alias_t& alias(void* p, unsigned offset)
 {
   return *reinterpret_cast<intptr_alias_t*>(static_cast<uint8_t*>(p) + offset);
 }
 
 #ifdef _MSC_VER
 
-inline int
-vsnprintf(char* dst, size_t size, const char* format, va_list a)
+inline int vsnprintf(char* dst, size_t size, const char* format, va_list a)
 {
   return vsnprintf_s(dst, size, _TRUNCATE, format, a);
 }
 
-inline int
-snprintf(char* dst, size_t size, const char* format, ...)
+inline int snprintf(char* dst, size_t size, const char* format, ...)
 {
   va_list a;
   va_start(a, format);
@@ -237,8 +240,7 @@ snprintf(char* dst, size_t size, const char* format, ...)
   return r;
 }
 
-inline FILE*
-fopen(const char* name, const char* mode)
+inline FILE* fopen(const char* name, const char* mode)
 {
   FILE* file;
   if (fopen_s(&file, name, mode) == 0) {
@@ -248,16 +250,14 @@ fopen(const char* name, const char* mode)
   }
 }
 
-#else // not _MSC_VER
+#else  // not _MSC_VER
 
-inline int
-vsnprintf(char* dst, size_t size, const char* format, va_list a)
+inline int vsnprintf(char* dst, size_t size, const char* format, va_list a)
 {
   return ::vsnprintf(dst, size, format, a);
 }
 
-inline int
-snprintf(char* dst, size_t size, const char* format, ...)
+inline int snprintf(char* dst, size_t size, const char* format, ...)
 {
   va_list a;
   va_start(a, format);
@@ -266,116 +266,105 @@ snprintf(char* dst, size_t size, const char* format, ...)
   return r;
 }
 
-inline FILE*
-fopen(const char* name, const char* mode)
+inline FILE* fopen(const char* name, const char* mode)
 {
   return ::fopen(name, mode);
 }
 
-#endif // not _MSC_VER
+#endif  // not _MSC_VER
 
 const unsigned BytesPerWord = sizeof(uintptr_t);
 const unsigned BitsPerWord = BytesPerWord * 8;
 
-const uintptr_t PointerMask
-= ((~static_cast<uintptr_t>(0)) / BytesPerWord) * BytesPerWord;
+const uintptr_t PointerMask = ((~static_cast<uintptr_t>(0)) / BytesPerWord)
+                              * BytesPerWord;
 
 const unsigned LikelyPageSizeInBytes = 4 * 1024;
 
-inline unsigned
-pad(unsigned n, unsigned alignment)
+inline unsigned pad(unsigned n, unsigned alignment)
 {
   return (n + (alignment - 1)) & ~(alignment - 1);
 }
 
-inline unsigned
-pad(unsigned n)
+inline unsigned pad(unsigned n)
 {
   return pad(n, BytesPerWord);
 }
 
-inline uintptr_t
-padWord(uintptr_t n, uintptr_t alignment)
+inline uintptr_t padWord(uintptr_t n, uintptr_t alignment)
 {
   return (n + (alignment - 1)) & ~(alignment - 1);
 }
 
-inline uintptr_t
-padWord(uintptr_t n)
+inline uintptr_t padWord(uintptr_t n)
 {
   return padWord(n, BytesPerWord);
 }
 
-inline bool fitsInInt8(int64_t v) {
+inline bool fitsInInt8(int64_t v)
+{
   return v == static_cast<int8_t>(v);
 }
 
-inline bool fitsInInt16(int64_t v) {
+inline bool fitsInInt16(int64_t v)
+{
   return v == static_cast<int16_t>(v);
 }
 
-inline bool fitsInInt32(int64_t v) {
+inline bool fitsInInt32(int64_t v)
+{
   return v == static_cast<int32_t>(v);
 }
 template <class T>
-inline unsigned
-wordOf(unsigned i)
+inline unsigned wordOf(unsigned i)
 {
   return i / (sizeof(T) * 8);
 }
 
-inline unsigned
-wordOf(unsigned i)
+inline unsigned wordOf(unsigned i)
 {
   return wordOf<uintptr_t>(i);
 }
 
 template <class T>
-inline unsigned
-bitOf(unsigned i)
+inline unsigned bitOf(unsigned i)
 {
   return i % (sizeof(T) * 8);
 }
 
-inline unsigned
-bitOf(unsigned i)
+inline unsigned bitOf(unsigned i)
 {
   return bitOf<uintptr_t>(i);
 }
 
 template <class T>
-inline unsigned
-indexOf(unsigned word, unsigned bit)
+inline unsigned indexOf(unsigned word, unsigned bit)
 {
   return (word * (sizeof(T) * 8)) + bit;
 }
 
-inline unsigned
-indexOf(unsigned word, unsigned bit)
+inline unsigned indexOf(unsigned word, unsigned bit)
 {
   return indexOf<uintptr_t>(word, bit);
 }
 
 template <class T>
-inline void
-markBit(T* map, unsigned i)
+inline void markBit(T* map, unsigned i)
 {
   map[wordOf<T>(i)] |= static_cast<T>(1) << bitOf<T>(i);
 }
 
 template <class T>
-inline void
-clearBit(T* map, unsigned i)
+inline void clearBit(T* map, unsigned i)
 {
   map[wordOf<T>(i)] &= ~(static_cast<T>(1) << bitOf<T>(i));
 }
 
 template <class T>
-inline unsigned
-getBit(T* map, unsigned i)
+inline unsigned getBit(T* map, unsigned i)
 {
   return (map[wordOf<T>(i)] & (static_cast<T>(1) << bitOf<T>(i)))
-    >> bitOf<T>(i);
+         >> bitOf<T>(i);
 }
 
 // todo: the following (clearBits, setBits, and getBits) could be made
@@ -383,8 +372,7 @@ getBit(T* map, unsigned i)
 // a time:
 
 template <class T>
-inline void
-clearBits(T* map, unsigned bitsPerRecord, unsigned index)
+inline void clearBits(T* map, unsigned bitsPerRecord, unsigned index)
 {
   for (unsigned i = index, limit = index + bitsPerRecord; i < limit; ++i) {
     clearBit<T>(map, i);
@@ -392,18 +380,19 @@ clearBits(T* map, unsigned bitsPerRecord, unsigned index)
 }
 
 template <class T>
-inline void
-setBits(T* map, unsigned bitsPerRecord, int index, unsigned v)
+inline void setBits(T* map, unsigned bitsPerRecord, int index, unsigned v)
 {
   for (int i = index + bitsPerRecord - 1; i >= index; --i) {
-    if (v & 1) markBit<T>(map, i); else clearBit<T>(map, i);
+    if (v & 1)
+      markBit<T>(map, i);
+    else
+      clearBit<T>(map, i);
     v >>= 1;
   }
 }
 
 template <class T>
-inline unsigned
-getBits(T* map, unsigned bitsPerRecord, unsigned index)
+inline unsigned getBits(T* map, unsigned bitsPerRecord, unsigned index)
 {
   unsigned v = 0;
   for (unsigned i = index, limit = index + bitsPerRecord; i < limit; ++i) {
@@ -414,86 +403,80 @@ getBits(T* map, unsigned bitsPerRecord, unsigned index)
 }
 
 template <class T>
-inline T&
-fieldAtOffset(void* p, unsigned offset)
+inline T& fieldAtOffset(void* p, unsigned offset)
 {
   return *reinterpret_cast<T*>(static_cast<uint8_t*>(p) + offset);
 }
 
 template <class T>
-inline T*
-maskAlignedPointer(T* p)
+inline T* maskAlignedPointer(T* p)
 {
   return reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(p) & PointerMask);
 }
 
-inline void
-write4(uint8_t* dst, uint32_t v)
+inline void write4(uint8_t* dst, uint32_t v)
 {
   memcpy(dst, &v, 4);
 }
 
-inline uint32_t
-floatToBits(float f)
+inline uint32_t floatToBits(float f)
 {
-  uint32_t bits; memcpy(&bits, &f, 4);
+  uint32_t bits;
+  memcpy(&bits, &f, 4);
   return bits;
 }
 
-inline uint64_t
-doubleToBits(double d)
+inline uint64_t doubleToBits(double d)
 {
-  uint64_t bits; memcpy(&bits, &d, 8);
+  uint64_t bits;
+  memcpy(&bits, &d, 8);
   return bits;
 }
 
-inline double
-bitsToDouble(uint64_t bits)
+inline double bitsToDouble(uint64_t bits)
 {
-  double d; memcpy(&d, &bits, 8);
+  double d;
+  memcpy(&d, &bits, 8);
   return d;
 }
 
-inline float
-bitsToFloat(uint32_t bits)
+inline float bitsToFloat(uint32_t bits)
 {
-  float f; memcpy(&f, &bits, 4);
+  float f;
+  memcpy(&f, &bits, 4);
   return f;
 }
 
-inline int
-difference(void* a, void* b)
+inline int difference(void* a, void* b)
 {
   return reinterpret_cast<intptr_t>(a) - reinterpret_cast<intptr_t>(b);
 }
 
 template <class T>
-inline void*
-voidPointer(T function)
+inline void* voidPointer(T function)
 {
   void* p;
   memcpy(&p, &function, sizeof(void*));
   return p;
 }
 
-inline void
-replace(char a, char b, char* c)
+inline void replace(char a, char b, char* c)
 {
-  for (; *c; ++c) if (*c == a) *c = b;
+  for (; *c; ++c)
+    if (*c == a)
+      *c = b;
 }
 
-inline void
-replace(char a, char b, char* dst, const char* src)
+inline void replace(char a, char b, char* dst, const char* src)
 {
   unsigned i = 0;
-  for (; src[i]; ++ i) {
+  for (; src[i]; ++i) {
     dst[i] = src[i] == a ? b : src[i];
   }
   dst[i] = 0;
 }
 
-inline bool
-equal(const void* a, unsigned al, const void* b, unsigned bl)
+inline bool equal(const void* a, unsigned al, const void* b, unsigned bl)
 {
   if (al == bl) {
     return memcmp(a, b, al) == 0;
@@ -502,6 +485,6 @@ equal(const void* a, unsigned al, const void* b, unsigned bl)
   }
 }
 
-} // namespace vm
+}  // namespace vm
 
-#endif // AVIAN_COMMON_H
+#endif  // AVIAN_COMMON_H
diff --git a/src/avian/constants.h b/src/avian/constants.h
index 5fa836c875..133c2e9ad5 100644
--- a/src/avian/constants.h
+++ b/src/avian/constants.h
@@ -248,35 +248,35 @@ enum Constant {
   CONSTANT_Utf8 = 1
 };
 
-const unsigned ACC_PUBLIC       = 1 <<  0;
-const unsigned ACC_PRIVATE      = 1 <<  1;
-const unsigned ACC_PROTECTED    = 1 <<  2;
-const unsigned ACC_STATIC       = 1 <<  3;
-const unsigned ACC_FINAL        = 1 <<  4;
-const unsigned ACC_SUPER        = 1 <<  5;
+const unsigned ACC_PUBLIC = 1 << 0;
+const unsigned ACC_PRIVATE = 1 << 1;
+const unsigned ACC_PROTECTED = 1 << 2;
+const unsigned ACC_STATIC = 1 << 3;
+const unsigned ACC_FINAL = 1 << 4;
+const unsigned ACC_SUPER = 1 << 5;
 const unsigned ACC_SYNCHRONIZED = ACC_SUPER;
-const unsigned ACC_VOLATILE     = 1 <<  6;
-const unsigned ACC_TRANSIENT    = 1 <<  7;
-const unsigned ACC_NATIVE       = 1 <<  8;
-const unsigned ACC_INTERFACE    = 1 <<  9;
-const unsigned ACC_ABSTRACT     = 1 << 10;
-const unsigned ACC_STRICT       = 1 << 11;
+const unsigned ACC_VOLATILE = 1 << 6;
+const unsigned ACC_TRANSIENT = 1 << 7;
+const unsigned ACC_NATIVE = 1 << 8;
+const unsigned ACC_INTERFACE = 1 << 9;
+const unsigned ACC_ABSTRACT = 1 << 10;
+const unsigned ACC_STRICT = 1 << 11;
 
 const int AVIAN_JNI_COMMIT = 1;
-const int AVIAN_JNI_ABORT  = 2;
+const int AVIAN_JNI_ABORT = 2;
 
-const int AVIAN_JNI_OK        =  0;
-const int AVIAN_JNI_ERR       = -1;
+const int AVIAN_JNI_OK = 0;
+const int AVIAN_JNI_ERR = -1;
 const int AVIAN_JNI_EDETACHED = -2;
-const int AVIAN_JNI_EVERSION  = -3;
-const int AVIAN_JNI_ENOMEM    = -4;
-const int AVIAN_JNI_EEXIST    = -5;
-const int AVIAN_JNI_EINVAL    = -6;
+const int AVIAN_JNI_EVERSION = -3;
+const int AVIAN_JNI_ENOMEM = -4;
+const int AVIAN_JNI_EEXIST = -5;
+const int AVIAN_JNI_EINVAL = -6;
 
 const int AVIAN_JNI_VERSION_1_1 = 0x00010001;
 const int AVIAN_JNI_VERSION_1_2 = 0x00010002;
 const int AVIAN_JNI_VERSION_1_4 = 0x00010004;
 
-} // namespace vm
+}  // namespace vm
 
-#endif//CONSTANTS_H
+#endif  // CONSTANTS_H
diff --git a/src/avian/environment.h b/src/avian/environment.h
index 147b866d87..8df211b559 100644
--- a/src/avian/environment.h
+++ b/src/avian/environment.h
@@ -30,4 +30,3 @@
 #define AVIAN_ARCH_ARM (3 << 8)
 
 #endif
-
diff --git a/src/avian/finder.h b/src/avian/finder.h
index 5089940ef7..cb37d2789b 100644
--- a/src/avian/finder.h
+++ b/src/avian/finder.h
@@ -30,96 +30,113 @@ const unsigned EntrySignature = 0x02014b50;
 
 const unsigned CentralDirectorySearchStart = 22;
 
-inline uint16_t get2(const uint8_t* p) {
-  return
-    (static_cast<uint16_t>(p[1]) <<  8) |
-    (static_cast<uint16_t>(p[0])      );
+inline uint16_t get2(const uint8_t* p)
+{
+  return (static_cast<uint16_t>(p[1]) << 8) | (static_cast<uint16_t>(p[0]));
 }
 
-inline uint32_t get4(const uint8_t* p) {
-  return
-    (static_cast<uint32_t>(p[3]) << 24) |
-    (static_cast<uint32_t>(p[2]) << 16) |
-    (static_cast<uint32_t>(p[1]) <<  8) |
-    (static_cast<uint32_t>(p[0])      );
+inline uint32_t get4(const uint8_t* p)
+{
+  return (static_cast<uint32_t>(p[3]) << 24)
+         | (static_cast<uint32_t>(p[2]) << 16)
+         | (static_cast<uint32_t>(p[1]) << 8) | (static_cast<uint32_t>(p[0]));
 }
 
-inline uint32_t signature(const uint8_t* p) {
+inline uint32_t signature(const uint8_t* p)
+{
   return get4(p);
 }
 
-inline uint16_t compressionMethod(const uint8_t* centralHeader) {
+inline uint16_t compressionMethod(const uint8_t* centralHeader)
+{
   return get2(centralHeader + 10);
 }
 
-inline uint32_t fileTime(const uint8_t* centralHeader) {
+inline uint32_t fileTime(const uint8_t* centralHeader)
+{
   return get4(centralHeader + 12);
 }
 
-inline uint32_t fileCRC(const uint8_t* centralHeader) {
+inline uint32_t fileCRC(const uint8_t* centralHeader)
+{
   return get4(centralHeader + 16);
 }
 
-inline uint32_t compressedSize(const uint8_t* centralHeader) {
+inline uint32_t compressedSize(const uint8_t* centralHeader)
+{
   return get4(centralHeader + 20);
 }
 
-inline uint32_t uncompressedSize(const uint8_t* centralHeader) {
+inline uint32_t uncompressedSize(const uint8_t* centralHeader)
+{
   return get4(centralHeader + 24);
 }
 
-inline uint16_t fileNameLength(const uint8_t* centralHeader) {
+inline uint16_t fileNameLength(const uint8_t* centralHeader)
+{
   return get2(centralHeader + 28);
 }
 
-inline uint16_t extraFieldLength(const uint8_t* centralHeader) {
+inline uint16_t extraFieldLength(const uint8_t* centralHeader)
+{
   return get2(centralHeader + 30);
 }
 
-inline uint16_t commentFieldLength(const uint8_t* centralHeader) {
+inline uint16_t commentFieldLength(const uint8_t* centralHeader)
+{
   return get2(centralHeader + 32);
 }
 
-inline uint32_t localHeaderOffset(const uint8_t* centralHeader) {
+inline uint32_t localHeaderOffset(const uint8_t* centralHeader)
+{
   return get4(centralHeader + 42);
 }
 
-inline uint16_t localFileNameLength(const uint8_t* localHeader) {
+inline uint16_t localFileNameLength(const uint8_t* localHeader)
+{
   return get2(localHeader + 26);
 }
 
-inline uint16_t localExtraFieldLength(const uint8_t* localHeader) {
+inline uint16_t localExtraFieldLength(const uint8_t* localHeader)
+{
   return get2(localHeader + 28);
 }
 
-inline uint32_t centralDirectoryOffset(const uint8_t* centralHeader) {
+inline uint32_t centralDirectoryOffset(const uint8_t* centralHeader)
+{
   return get4(centralHeader + 16);
 }
 
-inline const uint8_t* fileName(const uint8_t* centralHeader) {
+inline const uint8_t* fileName(const uint8_t* centralHeader)
+{
   return centralHeader + 46;
 }
 
-inline const uint8_t* fileData(const uint8_t* localHeader) {
-  return localHeader + LocalHeaderSize + localFileNameLength(localHeader) +
-    localExtraFieldLength(localHeader);
+inline const uint8_t* fileData(const uint8_t* localHeader)
+{
+  return localHeader + LocalHeaderSize + localFileNameLength(localHeader)
+         + localExtraFieldLength(localHeader);
 }
 
-inline const uint8_t* endOfEntry(const uint8_t* p) {
-  return p + HeaderSize + fileNameLength(p) + extraFieldLength(p) +
-    commentFieldLength(p);
+inline const uint8_t* endOfEntry(const uint8_t* p)
+{
+  return p + HeaderSize + fileNameLength(p) + extraFieldLength(p)
+         + commentFieldLength(p);
 }
 
-inline bool
-readLine(const uint8_t* base, unsigned total, unsigned* start,
-         unsigned* length)
+inline bool readLine(const uint8_t* base,
+                     unsigned total,
+                     unsigned* start,
+                     unsigned* length)
 {
   const uint8_t* p = base + *start;
   const uint8_t* end = base + total;
-  while (p != end and (*p == '\n' or *p == '\r')) ++ p;
+  while (p != end and (*p == '\n' or *p == '\r'))
+    ++p;
 
   *start = p - base;
-  while (p != end and not (*p == '\n' or *p == '\r')) ++ p;
+  while (p != end and not(*p == '\n' or *p == '\r'))
+    ++p;
 
   *length = (p - base) - *start;
 
@@ -136,22 +153,26 @@ class Finder {
 
   class Iterator {
    public:
-    Iterator(Finder* finder):
-      it(finder->iterator()),
-      current(it->next(&currentSize))
-    { }
+    Iterator(Finder* finder)
+        : it(finder->iterator()), current(it->next(&currentSize))
+    {
+    }
 
-    ~Iterator() {
+    ~Iterator()
+    {
       it->dispose();
     }
 
-    bool hasMore() {
-      if (current) return true;
+    bool hasMore()
+    {
+      if (current)
+        return true;
       current = it->next(&currentSize);
       return current != 0;
     }
 
-    const char* next(unsigned* size) {
+    const char* next(unsigned* size)
+    {
       if (hasMore()) {
         *size = currentSize;
         const char* v = current;
@@ -173,7 +194,8 @@ class Finder {
                                 unsigned* length,
                                 bool tryDirectory = false) = 0;
   virtual const char* urlPrefix(const char* name) = 0;
-  virtual const char* nextUrlPrefix(const char* name, void *&finderElementPtr) = 0;
+  virtual const char* nextUrlPrefix(const char* name, void*& finderElementPtr)
+      = 0;
   virtual const char* sourceUrl(const char* name) = 0;
   virtual const char* path() = 0;
   virtual void dispose() = 0;
@@ -189,6 +211,6 @@ Finder* makeFinder(System* s,
                    const uint8_t* jarData,
                    unsigned jarLength);
 
-} // namespace vm
+}  // namespace vm
 
-#endif//FINDER_H
+#endif  // FINDER_H
diff --git a/src/avian/heapwalk.h b/src/avian/heapwalk.h
index ae1d0df2d8..b104638b3f 100644
--- a/src/avian/heapwalk.h
+++ b/src/avian/heapwalk.h
@@ -29,8 +29,8 @@ class HeapVisitor {
   virtual void root() = 0;
   virtual unsigned visitNew(object value) = 0;
   virtual void visitOld(object value, unsigned number) = 0;
-  virtual void push(object parent, unsigned parentNumber,
-                    unsigned childOffset) = 0;
+  virtual void push(object parent, unsigned parentNumber, unsigned childOffset)
+      = 0;
   virtual void pop() = 0;
 };
 
@@ -42,9 +42,8 @@ class HeapWalker {
   virtual void dispose() = 0;
 };
 
-HeapWalker*
-makeHeapWalker(Thread* t, HeapVisitor* v);
+HeapWalker* makeHeapWalker(Thread* t, HeapVisitor* v);
 
-} // namespace vm
+}  // namespace vm
 
-#endif//HEAPWALK_H
+#endif  // HEAPWALK_H
diff --git a/src/avian/java-common.h b/src/avian/java-common.h
index bb8e5234f7..3ed4827989 100644
--- a/src/avian/java-common.h
+++ b/src/avian/java-common.h
@@ -68,16 +68,16 @@ typedef uintptr_t jmethodID;
 
 union jvalue {
   jboolean z;
-  jbyte    b;
-  jchar    c;
-  jshort   s;
-  jint     i;
-  jlong    j;
-  jfloat   f;
-  jdouble  d;
-  jobject  l;
+  jbyte b;
+  jchar c;
+  jshort s;
+  jint i;
+  jlong j;
+  jfloat f;
+  jdouble d;
+  jobject l;
 };
 
-} // namespace vm
+}  // namespace vm
 
-#endif // JAVA_COMMON_H
+#endif  // JAVA_COMMON_H
diff --git a/src/avian/jnienv.h b/src/avian/jnienv.h
index 50826733cb..2e9ae3d882 100644
--- a/src/avian/jnienv.h
+++ b/src/avian/jnienv.h
@@ -27,9 +27,8 @@
 
 namespace vm {
 
-void
-populateJNITables(JavaVMVTable* vmTable, JNIEnvVTable* envTable);
+void populateJNITables(JavaVMVTable* vmTable, JNIEnvVTable* envTable);
 
-} // namespace vm
+}  // namespace vm
 
-#endif//JNIENV_H
+#endif  // JNIENV_H
diff --git a/src/avian/lzma-util.h b/src/avian/lzma-util.h
index 73e8bcd294..bb60d2ba25 100644
--- a/src/avian/lzma-util.h
+++ b/src/avian/lzma-util.h
@@ -22,7 +22,8 @@ const unsigned Padding = 16;
 
 class LzmaAllocator {
  public:
-  LzmaAllocator(avian::util::Allocator* a): a(a) {
+  LzmaAllocator(avian::util::Allocator* a) : a(a)
+  {
     allocator.Alloc = allocate;
     allocator.Free = free;
   }
@@ -30,15 +31,17 @@ class LzmaAllocator {
   ISzAlloc allocator;
   avian::util::Allocator* a;
 
-  static void* allocate(void* allocator, size_t size) {
-    uint8_t* p = static_cast<uint8_t*>
-      (static_cast<LzmaAllocator*>(allocator)->a->allocate(size + Padding));
+  static void* allocate(void* allocator, size_t size)
+  {
+    uint8_t* p = static_cast<uint8_t*>(
+        static_cast<LzmaAllocator*>(allocator)->a->allocate(size + Padding));
     int32_t size32 = size;
     memcpy(p, &size32, 4);
     return p + Padding;
   }
 
-  static void free(void* allocator, void* address) {
+  static void free(void* allocator, void* address)
+  {
     if (address) {
       void* p = static_cast<uint8_t*>(address) - Padding;
       int32_t size32;
@@ -48,6 +51,6 @@ class LzmaAllocator {
   }
 };
 
-} // namespace vm
+}  // namespace vm
 
-#endif // LZMA_UTIL_H
+#endif  // LZMA_UTIL_H
diff --git a/src/avian/lzma.h b/src/avian/lzma.h
index 04afa81462..12642ded3f 100644
--- a/src/avian/lzma.h
+++ b/src/avian/lzma.h
@@ -33,6 +33,6 @@ uint8_t* encodeLZMA(System* s,
                     unsigned inSize,
                     unsigned* outSize);
 
-} // namespace vm
+}  // namespace vm
 
-#endif // LZMA_H
+#endif  // LZMA_H
diff --git a/src/avian/machine.h b/src/avian/machine.h
index cd78d0e9d5..4245dbb952 100644
--- a/src/avian/machine.h
+++ b/src/avian/machine.h
@@ -25,77 +25,104 @@
 using namespace avian::util;
 
 #ifdef PLATFORM_WINDOWS
-#  define JNICALL __stdcall
+#define JNICALL __stdcall
 #else
-#  define JNICALL
+#define JNICALL
 #endif
 
-#define PROTECT(thread, name)                                   \
-  Thread::SingleProtector MAKE_NAME(protector_) (thread, &name);
+#define PROTECT(thread, name) \
+  Thread::SingleProtector MAKE_NAME(protector_)(thread, &name);
 
-#define ACQUIRE(t, x) MonitorResource MAKE_NAME(monitorResource_) (t, x)
+#define ACQUIRE(t, x) MonitorResource MAKE_NAME(monitorResource_)(t, x)
 
 #define ACQUIRE_OBJECT(t, x) \
-  ObjectMonitorResource MAKE_NAME(monitorResource_) (t, x)
+  ObjectMonitorResource MAKE_NAME(monitorResource_)(t, x)
 
 #define ACQUIRE_FIELD_FOR_READ(t, field) \
-  FieldReadResource MAKE_NAME(monitorResource_) (t, field)
+  FieldReadResource MAKE_NAME(monitorResource_)(t, field)
 
 #define ACQUIRE_FIELD_FOR_WRITE(t, field) \
-  FieldWriteResource MAKE_NAME(monitorResource_) (t, field)
+  FieldWriteResource MAKE_NAME(monitorResource_)(t, field)
 
-#define ACQUIRE_RAW(t, x) RawMonitorResource MAKE_NAME(monitorResource_) (t, x)
+#define ACQUIRE_RAW(t, x) RawMonitorResource MAKE_NAME(monitorResource_)(t, x)
 
-#define ENTER(t, state) StateResource MAKE_NAME(stateResource_) (t, state)
+#define ENTER(t, state) StateResource MAKE_NAME(stateResource_)(t, state)
 
-#define THREAD_RESOURCE0(t, releaseBody)                                \
-  class MAKE_NAME(Resource_): public Thread::AutoResource {             \
-  public:                                                               \
-    MAKE_NAME(Resource_)(Thread* t): AutoResource(t) { }                \
-    ~MAKE_NAME(Resource_)() { releaseBody; }                            \
-    virtual void release()                                              \
-    { this->MAKE_NAME(Resource_)::~MAKE_NAME(Resource_)(); }            \
+#define THREAD_RESOURCE0(t, releaseBody)                     \
+  class MAKE_NAME(Resource_) : public Thread::AutoResource { \
+   public:                                                   \
+    MAKE_NAME(Resource_)(Thread * t) : AutoResource(t)       \
+    {                                                        \
+    }                                                        \
+    ~MAKE_NAME(Resource_)()                                  \
+    {                                                        \
+      releaseBody;                                           \
+    }                                                        \
+    virtual void release()                                   \
+    {                                                        \
+      this->MAKE_NAME(Resource_)::~MAKE_NAME(Resource_)();   \
+    }                                                        \
   } MAKE_NAME(resource_)(t);
 
-#define OBJECT_RESOURCE(t, name, releaseBody)                           \
-  class MAKE_NAME(Resource_): public Thread::AutoResource {             \
-  public:                                                               \
-    MAKE_NAME(Resource_)(Thread* t, object name):                       \
-      AutoResource(t), name(name), protector(t, &(this->name)) { }      \
-    ~MAKE_NAME(Resource_)() { releaseBody; }                            \
-    virtual void release()                                              \
-    { this->MAKE_NAME(Resource_)::~MAKE_NAME(Resource_)(); }            \
-                                                                        \
-  private:                                                              \
-    object name;                                                        \
-    Thread::SingleProtector protector;                                  \
+#define OBJECT_RESOURCE(t, name, releaseBody)                      \
+  class MAKE_NAME(Resource_) : public Thread::AutoResource {       \
+   public:                                                         \
+    MAKE_NAME(Resource_)(Thread * t, object name)                  \
+        : AutoResource(t), name(name), protector(t, &(this->name)) \
+    {                                                              \
+    }                                                              \
+    ~MAKE_NAME(Resource_)()                                        \
+    {                                                              \
+      releaseBody;                                                 \
+    }                                                              \
+    virtual void release()                                         \
+    {                                                              \
+      this->MAKE_NAME(Resource_)::~MAKE_NAME(Resource_)();         \
+    }                                                              \
+                                                                   \
+   private:                                                        \
+    object name;                                                   \
+    Thread::SingleProtector protector;                             \
   } MAKE_NAME(resource_)(t, name);
 
-#define THREAD_RESOURCE(t, type, name, releaseBody)                     \
-  class MAKE_NAME(Resource_): public Thread::AutoResource {             \
-  public:                                                               \
-    MAKE_NAME(Resource_)(Thread* t, type name):                         \
-      AutoResource(t), name(name) { }                                   \
-    ~MAKE_NAME(Resource_)() { releaseBody; }                            \
-    virtual void release()                                              \
-    { this->MAKE_NAME(Resource_)::~MAKE_NAME(Resource_)(); }            \
-                                                                        \
-  private:                                                              \
-    type name;                                                          \
+#define THREAD_RESOURCE(t, type, name, releaseBody)                           \
+  class MAKE_NAME(Resource_) : public Thread::AutoResource {                  \
+   public:                                                                    \
+    MAKE_NAME(Resource_)(Thread * t, type name) : AutoResource(t), name(name) \
+    {                                                                         \
+    }                                                                         \
+    ~MAKE_NAME(Resource_)()                                                   \
+    {                                                                         \
+      releaseBody;                                                            \
+    }                                                                         \
+    virtual void release()                                                    \
+    {                                                                         \
+      this->MAKE_NAME(Resource_)::~MAKE_NAME(Resource_)();                    \
+    }                                                                         \
+                                                                              \
+   private:                                                                   \
+    type name;                                                                \
   } MAKE_NAME(resource_)(t, name);
 
-#define THREAD_RESOURCE2(t, type1, name1, type2, name2, releaseBody)    \
-  class MAKE_NAME(Resource_): public Thread::AutoResource {             \
-  public:                                                               \
-    MAKE_NAME(Resource_)(Thread* t, type1 name1, type2 name2):          \
-      AutoResource(t), name1(name1), name2(name2) { }                   \
-    ~MAKE_NAME(Resource_)() { releaseBody; }                            \
-    virtual void release()                                              \
-    { this->MAKE_NAME(Resource_)::~MAKE_NAME(Resource_)(); }            \
-                                                                        \
-  private:                                                              \
-    type1 name1;                                                        \
-    type2 name2;                                                        \
+#define THREAD_RESOURCE2(t, type1, name1, type2, name2, releaseBody) \
+  class MAKE_NAME(Resource_) : public Thread::AutoResource {         \
+   public:                                                           \
+    MAKE_NAME(Resource_)(Thread * t, type1 name1, type2 name2)       \
+        : AutoResource(t), name1(name1), name2(name2)                \
+    {                                                                \
+    }                                                                \
+    ~MAKE_NAME(Resource_)()                                          \
+    {                                                                \
+      releaseBody;                                                   \
+    }                                                                \
+    virtual void release()                                           \
+    {                                                                \
+      this->MAKE_NAME(Resource_)::~MAKE_NAME(Resource_)();           \
+    }                                                                \
+                                                                     \
+   private:                                                          \
+    type1 name1;                                                     \
+    type2 name2;                                                     \
   } MAKE_NAME(resource_)(t, name1, name2);
 
 namespace vm {
@@ -116,13 +143,13 @@ const unsigned ThreadHeapSizeInBytes = 64 * 1024;
 const unsigned ThreadHeapSizeInWords = ThreadHeapSizeInBytes / BytesPerWord;
 
 const unsigned ThreadBackupHeapSizeInBytes = 2 * 1024;
-const unsigned ThreadBackupHeapSizeInWords
-= ThreadBackupHeapSizeInBytes / BytesPerWord;
+const unsigned ThreadBackupHeapSizeInWords = ThreadBackupHeapSizeInBytes
+                                             / BytesPerWord;
 
 const unsigned ThreadHeapPoolSize = 64;
 
-const unsigned FixedFootprintThresholdInBytes
-= ThreadHeapPoolSize * ThreadHeapSizeInBytes;
+const unsigned FixedFootprintThresholdInBytes = ThreadHeapPoolSize
+                                                * ThreadHeapSizeInBytes;
 
 // number of zombie threads which may accumulate before we force a GC
 // to clean them up:
@@ -142,7 +169,7 @@ enum FieldCode {
 };
 
 enum StackTag {
-  IntTag, // must be zero
+  IntTag,  // must be zero
   ObjectTag
 };
 
@@ -185,25 +212,15 @@ struct JavaVMVTable {
   void* reserved1;
   void* reserved2;
 
-  jint
-  (JNICALL *DestroyJavaVM)
-  (JavaVM*);
+  jint(JNICALL* DestroyJavaVM)(JavaVM*);
 
-  jint
-  (JNICALL *AttachCurrentThread)
-  (JavaVM*, JNIEnv**, void*);
+  jint(JNICALL* AttachCurrentThread)(JavaVM*, JNIEnv**, void*);
 
-  jint
-  (JNICALL *DetachCurrentThread)
-  (JavaVM*);
+  jint(JNICALL* DetachCurrentThread)(JavaVM*);
 
-  jint
-  (JNICALL *GetEnv)
-  (JavaVM*, JNIEnv**, jint);
+  jint(JNICALL* GetEnv)(JavaVM*, JNIEnv**, jint);
 
-  jint
-  (JNICALL *AttachCurrentThreadAsDaemon)
-  (JavaVM*, JNIEnv**, void*);
+  jint(JNICALL* AttachCurrentThreadAsDaemon)(JavaVM*, JNIEnv**, void*);
 };
 
 struct JNIEnvVTable {
@@ -212,960 +229,719 @@ struct JNIEnvVTable {
   void* reserved2;
   void* reserved3;
 
-  jint
-  (JNICALL *GetVersion)
-    (JNIEnv*);
+  jint(JNICALL* GetVersion)(JNIEnv*);
 
-  jclass
-  (JNICALL *DefineClass)
-    (JNIEnv*, const char*, jobject, const jbyte*, jsize);
+  jclass(
+      JNICALL* DefineClass)(JNIEnv*, const char*, jobject, const jbyte*, jsize);
 
-  jclass
-  (JNICALL *FindClass)
-    (JNIEnv*, const char*);
+  jclass(JNICALL* FindClass)(JNIEnv*, const char*);
 
-  jmethodID
-  (JNICALL *FromReflectedMethod)
-    (JNIEnv*, jobject);
+  jmethodID(JNICALL* FromReflectedMethod)(JNIEnv*, jobject);
 
-  jfieldID
-  (JNICALL *FromReflectedField)
-    (JNIEnv*, jobject);
+  jfieldID(JNICALL* FromReflectedField)(JNIEnv*, jobject);
 
-  jobject
-  (JNICALL *ToReflectedMethod)
-    (JNIEnv*, jclass, jmethodID, jboolean);
+  jobject(JNICALL* ToReflectedMethod)(JNIEnv*, jclass, jmethodID, jboolean);
 
-  jclass
-  (JNICALL *GetSuperclass)
-    (JNIEnv*, jclass);
+  jclass(JNICALL* GetSuperclass)(JNIEnv*, jclass);
 
-  jboolean
-  (JNICALL *IsAssignableFrom)
-    (JNIEnv*, jclass, jclass);
+  jboolean(JNICALL* IsAssignableFrom)(JNIEnv*, jclass, jclass);
 
-  jobject
-  (JNICALL *ToReflectedField)
-    (JNIEnv*, jclass, jfieldID, jboolean);
+  jobject(JNICALL* ToReflectedField)(JNIEnv*, jclass, jfieldID, jboolean);
 
-  jint
-  (JNICALL *Throw)
-    (JNIEnv*, jthrowable);
+  jint(JNICALL* Throw)(JNIEnv*, jthrowable);
 
-  jint
-  (JNICALL *ThrowNew)
-    (JNIEnv*, jclass, const char*);
+  jint(JNICALL* ThrowNew)(JNIEnv*, jclass, const char*);
 
-  jthrowable
-  (JNICALL *ExceptionOccurred)
-    (JNIEnv*);
+  jthrowable(JNICALL* ExceptionOccurred)(JNIEnv*);
 
-  void
-  (JNICALL *ExceptionDescribe)
-  (JNIEnv*);
+  void(JNICALL* ExceptionDescribe)(JNIEnv*);
 
-  void
-  (JNICALL *ExceptionClear)
-  (JNIEnv*);
+  void(JNICALL* ExceptionClear)(JNIEnv*);
 
-  void
-  (JNICALL *FatalError)
-  (JNIEnv*, const char*);
+  void(JNICALL* FatalError)(JNIEnv*, const char*);
 
-  jint
-  (JNICALL *PushLocalFrame)
-    (JNIEnv*, jint);
+  jint(JNICALL* PushLocalFrame)(JNIEnv*, jint);
 
-  jobject
-  (JNICALL *PopLocalFrame)
-    (JNIEnv*, jobject);
+  jobject(JNICALL* PopLocalFrame)(JNIEnv*, jobject);
 
-  jobject
-  (JNICALL *NewGlobalRef)
-    (JNIEnv*, jobject);
+  jobject(JNICALL* NewGlobalRef)(JNIEnv*, jobject);
 
-  void
-  (JNICALL *DeleteGlobalRef)
-  (JNIEnv*, jobject);
+  void(JNICALL* DeleteGlobalRef)(JNIEnv*, jobject);
 
-  void
-  (JNICALL *DeleteLocalRef)
-  (JNIEnv*, jobject);
+  void(JNICALL* DeleteLocalRef)(JNIEnv*, jobject);
 
-  jboolean
-  (JNICALL *IsSameObject)
-    (JNIEnv*, jobject, jobject);
+  jboolean(JNICALL* IsSameObject)(JNIEnv*, jobject, jobject);
 
-  jobject
-  (JNICALL *NewLocalRef)
-    (JNIEnv*, jobject);
+  jobject(JNICALL* NewLocalRef)(JNIEnv*, jobject);
 
-  jint
-  (JNICALL *EnsureLocalCapacity)
-    (JNIEnv*, jint);
+  jint(JNICALL* EnsureLocalCapacity)(JNIEnv*, jint);
 
-  jobject
-  (JNICALL *AllocObject)
-    (JNIEnv*, jclass);
+  jobject(JNICALL* AllocObject)(JNIEnv*, jclass);
 
-  jobject
-  (JNICALL *NewObject)
-    (JNIEnv*, jclass, jmethodID, ...);
+  jobject(JNICALL* NewObject)(JNIEnv*, jclass, jmethodID, ...);
 
-  jobject
-  (JNICALL *NewObjectV)
-    (JNIEnv*, jclass, jmethodID, va_list);
+  jobject(JNICALL* NewObjectV)(JNIEnv*, jclass, jmethodID, va_list);
 
-  jobject
-  (JNICALL *NewObjectA)
-    (JNIEnv*, jclass, jmethodID, const jvalue*);
+  jobject(JNICALL* NewObjectA)(JNIEnv*, jclass, jmethodID, const jvalue*);
 
-  jclass
-  (JNICALL *GetObjectClass)
-    (JNIEnv*, jobject);
+  jclass(JNICALL* GetObjectClass)(JNIEnv*, jobject);
 
-  jboolean
-  (JNICALL *IsInstanceOf)
-    (JNIEnv*, jobject, jclass);
+  jboolean(JNICALL* IsInstanceOf)(JNIEnv*, jobject, jclass);
 
-  jmethodID
-  (JNICALL *GetMethodID)
-    (JNIEnv*, jclass, const char*, const char*);
+  jmethodID(JNICALL* GetMethodID)(JNIEnv*, jclass, const char*, const char*);
 
-  jobject
-  (JNICALL *CallObjectMethod)
-    (JNIEnv*, jobject, jmethodID, ...);
+  jobject(JNICALL* CallObjectMethod)(JNIEnv*, jobject, jmethodID, ...);
 
-  jobject
-  (JNICALL *CallObjectMethodV)
-    (JNIEnv*, jobject, jmethodID, va_list);
+  jobject(JNICALL* CallObjectMethodV)(JNIEnv*, jobject, jmethodID, va_list);
 
-  jobject
-  (JNICALL *CallObjectMethodA)
-    (JNIEnv*, jobject, jmethodID, const jvalue*);
+  jobject(JNICALL* CallObjectMethodA)(JNIEnv*,
+                                      jobject,
+                                      jmethodID,
+                                      const jvalue*);
 
-  jboolean
-  (JNICALL *CallBooleanMethod)
-    (JNIEnv*, jobject, jmethodID, ...);
+  jboolean(JNICALL* CallBooleanMethod)(JNIEnv*, jobject, jmethodID, ...);
 
-  jboolean
-  (JNICALL *CallBooleanMethodV)
-    (JNIEnv*, jobject, jmethodID, va_list);
+  jboolean(JNICALL* CallBooleanMethodV)(JNIEnv*, jobject, jmethodID, va_list);
 
-  jboolean
-  (JNICALL *CallBooleanMethodA)
-    (JNIEnv*, jobject, jmethodID, const jvalue*);
+  jboolean(JNICALL* CallBooleanMethodA)(JNIEnv*,
+                                        jobject,
+                                        jmethodID,
+                                        const jvalue*);
 
-  jbyte
-  (JNICALL *CallByteMethod)
-    (JNIEnv*, jobject, jmethodID, ...);
+  jbyte(JNICALL* CallByteMethod)(JNIEnv*, jobject, jmethodID, ...);
 
-  jbyte
-  (JNICALL *CallByteMethodV)
-    (JNIEnv*, jobject, jmethodID, va_list);
+  jbyte(JNICALL* CallByteMethodV)(JNIEnv*, jobject, jmethodID, va_list);
 
-  jbyte
-  (JNICALL *CallByteMethodA)
-    (JNIEnv*, jobject, jmethodID, const jvalue*);
+  jbyte(JNICALL* CallByteMethodA)(JNIEnv*, jobject, jmethodID, const jvalue*);
 
-  jchar
-  (JNICALL *CallCharMethod)
-    (JNIEnv*, jobject, jmethodID, ...);
+  jchar(JNICALL* CallCharMethod)(JNIEnv*, jobject, jmethodID, ...);
 
-  jchar
-  (JNICALL *CallCharMethodV)
-    (JNIEnv*, jobject, jmethodID, va_list);
+  jchar(JNICALL* CallCharMethodV)(JNIEnv*, jobject, jmethodID, va_list);
 
-  jchar
-  (JNICALL *CallCharMethodA)
-    (JNIEnv*, jobject, jmethodID, const jvalue*);
+  jchar(JNICALL* CallCharMethodA)(JNIEnv*, jobject, jmethodID, const jvalue*);
 
-  jshort
-  (JNICALL *CallShortMethod)
-    (JNIEnv*, jobject, jmethodID, ...);
+  jshort(JNICALL* CallShortMethod)(JNIEnv*, jobject, jmethodID, ...);
 
-  jshort
-  (JNICALL *CallShortMethodV)
-    (JNIEnv*, jobject, jmethodID, va_list);
+  jshort(JNICALL* CallShortMethodV)(JNIEnv*, jobject, jmethodID, va_list);
 
-  jshort
-  (JNICALL *CallShortMethodA)
-    (JNIEnv*, jobject, jmethodID, const jvalue*);
+  jshort(JNICALL* CallShortMethodA)(JNIEnv*, jobject, jmethodID, const jvalue*);
 
-  jint
-  (JNICALL *CallIntMethod)
-    (JNIEnv*, jobject, jmethodID, ...);
+  jint(JNICALL* CallIntMethod)(JNIEnv*, jobject, jmethodID, ...);
 
-  jint
-  (JNICALL *CallIntMethodV)
-    (JNIEnv*, jobject, jmethodID, va_list);
+  jint(JNICALL* CallIntMethodV)(JNIEnv*, jobject, jmethodID, va_list);
 
-  jint
-  (JNICALL *CallIntMethodA)
-    (JNIEnv*, jobject, jmethodID, const jvalue*);
+  jint(JNICALL* CallIntMethodA)(JNIEnv*, jobject, jmethodID, const jvalue*);
 
-  jlong
-  (JNICALL *CallLongMethod)
-    (JNIEnv*, jobject, jmethodID, ...);
+  jlong(JNICALL* CallLongMethod)(JNIEnv*, jobject, jmethodID, ...);
 
-  jlong
-  (JNICALL *CallLongMethodV)
-    (JNIEnv*, jobject, jmethodID, va_list);
+  jlong(JNICALL* CallLongMethodV)(JNIEnv*, jobject, jmethodID, va_list);
 
-  jlong
-  (JNICALL *CallLongMethodA)
-    (JNIEnv*, jobject, jmethodID, const jvalue*);
+  jlong(JNICALL* CallLongMethodA)(JNIEnv*, jobject, jmethodID, const jvalue*);
 
-  jfloat
-  (JNICALL *CallFloatMethod)
-  (JNIEnv*, jobject, jmethodID, ...);
+  jfloat(JNICALL* CallFloatMethod)(JNIEnv*, jobject, jmethodID, ...);
 
-  jfloat
-  (JNICALL *CallFloatMethodV)
-  (JNIEnv*, jobject, jmethodID, va_list);
+  jfloat(JNICALL* CallFloatMethodV)(JNIEnv*, jobject, jmethodID, va_list);
 
-  jfloat
-  (JNICALL *CallFloatMethodA)
-  (JNIEnv*, jobject, jmethodID, const jvalue*);
+  jfloat(JNICALL* CallFloatMethodA)(JNIEnv*, jobject, jmethodID, const jvalue*);
 
-  jdouble
-  (JNICALL *CallDoubleMethod)
-  (JNIEnv*, jobject, jmethodID, ...);
+  jdouble(JNICALL* CallDoubleMethod)(JNIEnv*, jobject, jmethodID, ...);
 
-  jdouble
-  (JNICALL *CallDoubleMethodV)
-  (JNIEnv*, jobject, jmethodID, va_list);
-
-  jdouble
-  (JNICALL *CallDoubleMethodA)
-  (JNIEnv*, jobject, jmethodID, const jvalue*);
-
-  void
-  (JNICALL *CallVoidMethod)
-  (JNIEnv*, jobject, jmethodID, ...);
-
-  void
-  (JNICALL *CallVoidMethodV)
-  (JNIEnv*, jobject, jmethodID, va_list);
-
-  void
-  (JNICALL *CallVoidMethodA)
-  (JNIEnv*, jobject, jmethodID, const jvalue*);
-
-  jobject
-  (JNICALL *CallNonvirtualObjectMethod)
-    (JNIEnv*, jobject, jclass, jmethodID, ...);
-
-  jobject
-  (JNICALL *CallNonvirtualObjectMethodV)
-    (JNIEnv*, jobject, jclass, jmethodID, va_list);
-
-  jobject
-  (JNICALL *CallNonvirtualObjectMethodA)
-    (JNIEnv*, jobject, jclass, jmethodID, const jvalue*);
-
-  jboolean
-  (JNICALL *CallNonvirtualBooleanMethod)
-    (JNIEnv*, jobject, jclass, jmethodID, ...);
-
-  jboolean
-  (JNICALL *CallNonvirtualBooleanMethodV)
-    (JNIEnv*, jobject, jclass, jmethodID, va_list);
-
-  jboolean
-  (JNICALL *CallNonvirtualBooleanMethodA)
-    (JNIEnv*, jobject, jclass, jmethodID, const jvalue*);
-
-  jbyte
-  (JNICALL *CallNonvirtualByteMethod)
-    (JNIEnv*, jobject, jclass, jmethodID, ...);
-
-  jbyte
-  (JNICALL *CallNonvirtualByteMethodV)
-    (JNIEnv*, jobject, jclass, jmethodID, va_list);
-
-  jbyte
-  (JNICALL *CallNonvirtualByteMethodA)
-    (JNIEnv*, jobject, jclass, jmethodID, const jvalue*);
-
-  jchar
-  (JNICALL *CallNonvirtualCharMethod)
-    (JNIEnv*, jobject, jclass, jmethodID, ...);
-
-  jchar
-  (JNICALL *CallNonvirtualCharMethodV)
-    (JNIEnv*, jobject, jclass, jmethodID, va_list);
-
-  jchar
-  (JNICALL *CallNonvirtualCharMethodA)
-    (JNIEnv*, jobject, jclass, jmethodID, const jvalue*);
-
-  jshort
-  (JNICALL *CallNonvirtualShortMethod)
-    (JNIEnv*, jobject, jclass, jmethodID, ...);
-
-  jshort
-  (JNICALL *CallNonvirtualShortMethodV)
-    (JNIEnv*, jobject, jclass, jmethodID,
-     va_list);
-
-  jshort
-  (JNICALL *CallNonvirtualShortMethodA)
-    (JNIEnv*, jobject, jclass, jmethodID,
-     const jvalue*);
-
-  jint
-  (JNICALL *CallNonvirtualIntMethod)
-    (JNIEnv*, jobject, jclass, jmethodID, ...);
-
-  jint
-  (JNICALL *CallNonvirtualIntMethodV)
-    (JNIEnv*, jobject, jclass, jmethodID,
-     va_list);
-
-  jint
-  (JNICALL *CallNonvirtualIntMethodA)
-    (JNIEnv*, jobject, jclass, jmethodID,
-     const jvalue*);
-
-  jlong
-  (JNICALL *CallNonvirtualLongMethod)
-    (JNIEnv*, jobject, jclass, jmethodID, ...);
-
-  jlong
-  (JNICALL *CallNonvirtualLongMethodV)
-    (JNIEnv*, jobject, jclass, jmethodID,
-     va_list);
-  jlong
-  (JNICALL *CallNonvirtualLongMethodA)
-    (JNIEnv*, jobject, jclass, jmethodID, const jvalue*);
-
-  jfloat
-  (JNICALL *CallNonvirtualFloatMethod)
-  (JNIEnv*, jobject, jclass, jmethodID, ...);
-
-  jfloat
-  (JNICALL *CallNonvirtualFloatMethodV)
-  (JNIEnv*, jobject, jclass, jmethodID, va_list);
-
-  jfloat
-  (JNICALL *CallNonvirtualFloatMethodA)
-  (JNIEnv*, jobject, jclass, jmethodID, const jvalue*);
-
-  jdouble
-  (JNICALL *CallNonvirtualDoubleMethod)
-  (JNIEnv*, jobject, jclass, jmethodID, ...);
-
-  jdouble
-  (JNICALL *CallNonvirtualDoubleMethodV)
-  (JNIEnv*, jobject, jclass, jmethodID, va_list);
-
-  jdouble
-  (JNICALL *CallNonvirtualDoubleMethodA)
-  (JNIEnv*, jobject, jclass, jmethodID, const jvalue*);
-
-  void
-  (JNICALL *CallNonvirtualVoidMethod)
-  (JNIEnv*, jobject, jclass, jmethodID, ...);
-
-  void
-  (JNICALL *CallNonvirtualVoidMethodV)
-  (JNIEnv*, jobject, jclass, jmethodID, va_list);
-
-  void
-  (JNICALL *CallNonvirtualVoidMethodA)
-  (JNIEnv*, jobject, jclass, jmethodID, const jvalue*);
-
-  jfieldID
-  (JNICALL *GetFieldID)
-    (JNIEnv*, jclass, const char*, const char*);
-
-  jobject
-  (JNICALL *GetObjectField)
-    (JNIEnv*, jobject, jfieldID);
-
-  jboolean
-  (JNICALL *GetBooleanField)
-    (JNIEnv*, jobject, jfieldID);
-
-  jbyte
-  (JNICALL *GetByteField)
-    (JNIEnv*, jobject, jfieldID);
-
-  jchar
-  (JNICALL *GetCharField)
-    (JNIEnv*, jobject, jfieldID);
-
-  jshort
-  (JNICALL *GetShortField)
-    (JNIEnv*, jobject, jfieldID);
-
-  jint
-  (JNICALL *GetIntField)
-    (JNIEnv*, jobject, jfieldID);
-
-  jlong
-  (JNICALL *GetLongField)
-    (JNIEnv*, jobject, jfieldID);
-
-  jfloat
-  (JNICALL *GetFloatField)
-  (JNIEnv*, jobject, jfieldID);
-
-  jdouble
-  (JNICALL *GetDoubleField)
-  (JNIEnv*, jobject, jfieldID);
-
-  void
-  (JNICALL *SetObjectField)
-  (JNIEnv*, jobject, jfieldID, jobject);
-
-  void
-  (JNICALL *SetBooleanField)
-  (JNIEnv*, jobject, jfieldID, jboolean);
-
-  void
-  (JNICALL *SetByteField)
-  (JNIEnv*, jobject, jfieldID, jbyte);
+  jdouble(JNICALL* CallDoubleMethodV)(JNIEnv*, jobject, jmethodID, va_list);
 
-  void
-  (JNICALL *SetCharField)
-  (JNIEnv*, jobject, jfieldID, jchar);
+  jdouble(JNICALL* CallDoubleMethodA)(JNIEnv*,
+                                      jobject,
+                                      jmethodID,
+                                      const jvalue*);
 
-  void
-  (JNICALL *SetShortField)
-  (JNIEnv*, jobject, jfieldID, jshort);
+  void(JNICALL* CallVoidMethod)(JNIEnv*, jobject, jmethodID, ...);
 
-  void
-  (JNICALL *SetIntField)
-  (JNIEnv*, jobject, jfieldID, jint);
+  void(JNICALL* CallVoidMethodV)(JNIEnv*, jobject, jmethodID, va_list);
 
-  void
-  (JNICALL *SetLongField)
-  (JNIEnv*, jobject, jfieldID, jlong);
+  void(JNICALL* CallVoidMethodA)(JNIEnv*, jobject, jmethodID, const jvalue*);
 
-  void
-  (JNICALL *SetFloatField)
-  (JNIEnv*, jobject, jfieldID, jfloat);
+  jobject(JNICALL* CallNonvirtualObjectMethod)(JNIEnv*,
+                                               jobject,
+                                               jclass,
+                                               jmethodID,
+                                               ...);
 
-  void
-  (JNICALL *SetDoubleField)
-  (JNIEnv*, jobject, jfieldID, jdouble);
+  jobject(JNICALL* CallNonvirtualObjectMethodV)(JNIEnv*,
+                                                jobject,
+                                                jclass,
+                                                jmethodID,
+                                                va_list);
 
-  jmethodID
-  (JNICALL *GetStaticMethodID)
-    (JNIEnv*, jclass, const char*, const char*);
+  jobject(JNICALL* CallNonvirtualObjectMethodA)(JNIEnv*,
+                                                jobject,
+                                                jclass,
+                                                jmethodID,
+                                                const jvalue*);
 
-  jobject
-  (JNICALL *CallStaticObjectMethod)
-    (JNIEnv*, jclass, jmethodID, ...);
+  jboolean(JNICALL* CallNonvirtualBooleanMethod)(JNIEnv*,
+                                                 jobject,
+                                                 jclass,
+                                                 jmethodID,
+                                                 ...);
 
-  jobject
-  (JNICALL *CallStaticObjectMethodV)
-    (JNIEnv*, jclass, jmethodID, va_list);
+  jboolean(JNICALL* CallNonvirtualBooleanMethodV)(JNIEnv*,
+                                                  jobject,
+                                                  jclass,
+                                                  jmethodID,
+                                                  va_list);
 
-  jobject
-  (JNICALL *CallStaticObjectMethodA)
-    (JNIEnv*, jclass, jmethodID, const jvalue*);
+  jboolean(JNICALL* CallNonvirtualBooleanMethodA)(JNIEnv*,
+                                                  jobject,
+                                                  jclass,
+                                                  jmethodID,
+                                                  const jvalue*);
+
+  jbyte(JNICALL* CallNonvirtualByteMethod)(JNIEnv*,
+                                           jobject,
+                                           jclass,
+                                           jmethodID,
+                                           ...);
+
+  jbyte(JNICALL* CallNonvirtualByteMethodV)(JNIEnv*,
+                                            jobject,
+                                            jclass,
+                                            jmethodID,
+                                            va_list);
+
+  jbyte(JNICALL* CallNonvirtualByteMethodA)(JNIEnv*,
+                                            jobject,
+                                            jclass,
+                                            jmethodID,
+                                            const jvalue*);
+
+  jchar(JNICALL* CallNonvirtualCharMethod)(JNIEnv*,
+                                           jobject,
+                                           jclass,
+                                           jmethodID,
+                                           ...);
+
+  jchar(JNICALL* CallNonvirtualCharMethodV)(JNIEnv*,
+                                            jobject,
+                                            jclass,
+                                            jmethodID,
+                                            va_list);
+
+  jchar(JNICALL* CallNonvirtualCharMethodA)(JNIEnv*,
+                                            jobject,
+                                            jclass,
+                                            jmethodID,
+                                            const jvalue*);
+
+  jshort(JNICALL* CallNonvirtualShortMethod)(JNIEnv*,
+                                             jobject,
+                                             jclass,
+                                             jmethodID,
+                                             ...);
+
+  jshort(JNICALL* CallNonvirtualShortMethodV)(JNIEnv*,
+                                              jobject,
+                                              jclass,
+                                              jmethodID,
+                                              va_list);
+
+  jshort(JNICALL* CallNonvirtualShortMethodA)(JNIEnv*,
+                                              jobject,
+                                              jclass,
+                                              jmethodID,
+                                              const jvalue*);
+
+  jint(JNICALL* CallNonvirtualIntMethod)(JNIEnv*,
+                                         jobject,
+                                         jclass,
+                                         jmethodID,
+                                         ...);
+
+  jint(JNICALL* CallNonvirtualIntMethodV)(JNIEnv*,
+                                          jobject,
+                                          jclass,
+                                          jmethodID,
+                                          va_list);
+
+  jint(JNICALL* CallNonvirtualIntMethodA)(JNIEnv*,
+                                          jobject,
+                                          jclass,
+                                          jmethodID,
+                                          const jvalue*);
+
+  jlong(JNICALL* CallNonvirtualLongMethod)(JNIEnv*,
+                                           jobject,
+                                           jclass,
+                                           jmethodID,
+                                           ...);
+
+  jlong(JNICALL* CallNonvirtualLongMethodV)(JNIEnv*,
+                                            jobject,
+                                            jclass,
+                                            jmethodID,
+                                            va_list);
+  jlong(JNICALL* CallNonvirtualLongMethodA)(JNIEnv*,
+                                            jobject,
+                                            jclass,
+                                            jmethodID,
+                                            const jvalue*);
+
+  jfloat(JNICALL* CallNonvirtualFloatMethod)(JNIEnv*,
+                                             jobject,
+                                             jclass,
+                                             jmethodID,
+                                             ...);
+
+  jfloat(JNICALL* CallNonvirtualFloatMethodV)(JNIEnv*,
+                                              jobject,
+                                              jclass,
+                                              jmethodID,
+                                              va_list);
+
+  jfloat(JNICALL* CallNonvirtualFloatMethodA)(JNIEnv*,
+                                              jobject,
+                                              jclass,
+                                              jmethodID,
+                                              const jvalue*);
+
+  jdouble(JNICALL* CallNonvirtualDoubleMethod)(JNIEnv*,
+                                               jobject,
+                                               jclass,
+                                               jmethodID,
+                                               ...);
+
+  jdouble(JNICALL* CallNonvirtualDoubleMethodV)(JNIEnv*,
+                                                jobject,
+                                                jclass,
+                                                jmethodID,
+                                                va_list);
+
+  jdouble(JNICALL* CallNonvirtualDoubleMethodA)(JNIEnv*,
+                                                jobject,
+                                                jclass,
+                                                jmethodID,
+                                                const jvalue*);
 
-  jboolean
-  (JNICALL *CallStaticBooleanMethod)
-    (JNIEnv*, jclass, jmethodID, ...);
+  void(JNICALL* CallNonvirtualVoidMethod)(JNIEnv*,
+                                          jobject,
+                                          jclass,
+                                          jmethodID,
+                                          ...);
 
-  jboolean
-  (JNICALL *CallStaticBooleanMethodV)
-    (JNIEnv*, jclass, jmethodID, va_list);
+  void(JNICALL* CallNonvirtualVoidMethodV)(JNIEnv*,
+                                           jobject,
+                                           jclass,
+                                           jmethodID,
+                                           va_list);
 
-  jboolean
-  (JNICALL *CallStaticBooleanMethodA)
-    (JNIEnv*, jclass, jmethodID, const jvalue*);
+  void(JNICALL* CallNonvirtualVoidMethodA)(JNIEnv*,
+                                           jobject,
+                                           jclass,
+                                           jmethodID,
+                                           const jvalue*);
 
-  jbyte
-  (JNICALL *CallStaticByteMethod)
-    (JNIEnv*, jclass, jmethodID, ...);
+  jfieldID(JNICALL* GetFieldID)(JNIEnv*, jclass, const char*, const char*);
 
-  jbyte
-  (JNICALL *CallStaticByteMethodV)
-    (JNIEnv*, jclass, jmethodID, va_list);
+  jobject(JNICALL* GetObjectField)(JNIEnv*, jobject, jfieldID);
 
-  jbyte
-  (JNICALL *CallStaticByteMethodA)
-    (JNIEnv*, jclass, jmethodID, const jvalue*);
+  jboolean(JNICALL* GetBooleanField)(JNIEnv*, jobject, jfieldID);
 
-  jchar
-  (JNICALL *CallStaticCharMethod)
-    (JNIEnv*, jclass, jmethodID, ...);
+  jbyte(JNICALL* GetByteField)(JNIEnv*, jobject, jfieldID);
 
-  jchar
-  (JNICALL *CallStaticCharMethodV)
-    (JNIEnv*, jclass, jmethodID, va_list);
+  jchar(JNICALL* GetCharField)(JNIEnv*, jobject, jfieldID);
 
-  jchar
-  (JNICALL *CallStaticCharMethodA)
-    (JNIEnv*, jclass, jmethodID, const jvalue*);
+  jshort(JNICALL* GetShortField)(JNIEnv*, jobject, jfieldID);
 
-  jshort
-  (JNICALL *CallStaticShortMethod)
-    (JNIEnv*, jclass, jmethodID, ...);
+  jint(JNICALL* GetIntField)(JNIEnv*, jobject, jfieldID);
 
-  jshort
-  (JNICALL *CallStaticShortMethodV)
-    (JNIEnv*, jclass, jmethodID, va_list);
+  jlong(JNICALL* GetLongField)(JNIEnv*, jobject, jfieldID);
 
-  jshort
-  (JNICALL *CallStaticShortMethodA)
-    (JNIEnv*, jclass, jmethodID, const jvalue*);
+  jfloat(JNICALL* GetFloatField)(JNIEnv*, jobject, jfieldID);
 
-  jint
-  (JNICALL *CallStaticIntMethod)
-    (JNIEnv*, jclass, jmethodID, ...);
+  jdouble(JNICALL* GetDoubleField)(JNIEnv*, jobject, jfieldID);
 
-  jint
-  (JNICALL *CallStaticIntMethodV)
-    (JNIEnv*, jclass, jmethodID, va_list);
+  void(JNICALL* SetObjectField)(JNIEnv*, jobject, jfieldID, jobject);
 
-  jint
-  (JNICALL *CallStaticIntMethodA)
-    (JNIEnv*, jclass, jmethodID, const jvalue*);
+  void(JNICALL* SetBooleanField)(JNIEnv*, jobject, jfieldID, jboolean);
 
-  jlong
-  (JNICALL *CallStaticLongMethod)
-    (JNIEnv*, jclass, jmethodID, ...);
+  void(JNICALL* SetByteField)(JNIEnv*, jobject, jfieldID, jbyte);
 
-  jlong
-  (JNICALL *CallStaticLongMethodV)
-    (JNIEnv*, jclass, jmethodID, va_list);
+  void(JNICALL* SetCharField)(JNIEnv*, jobject, jfieldID, jchar);
 
-  jlong
-  (JNICALL *CallStaticLongMethodA)
-    (JNIEnv*, jclass, jmethodID, const jvalue*);
+  void(JNICALL* SetShortField)(JNIEnv*, jobject, jfieldID, jshort);
 
-  jfloat
-  (JNICALL *CallStaticFloatMethod)
-  (JNIEnv*, jclass, jmethodID, ...);
+  void(JNICALL* SetIntField)(JNIEnv*, jobject, jfieldID, jint);
 
-  jfloat
-  (JNICALL *CallStaticFloatMethodV)
-  (JNIEnv*, jclass, jmethodID, va_list);
+  void(JNICALL* SetLongField)(JNIEnv*, jobject, jfieldID, jlong);
 
-  jfloat
-  (JNICALL *CallStaticFloatMethodA)
-  (JNIEnv*, jclass, jmethodID, const jvalue*);
+  void(JNICALL* SetFloatField)(JNIEnv*, jobject, jfieldID, jfloat);
 
-  jdouble
-  (JNICALL *CallStaticDoubleMethod)
-  (JNIEnv*, jclass, jmethodID, ...);
+  void(JNICALL* SetDoubleField)(JNIEnv*, jobject, jfieldID, jdouble);
 
-  jdouble
-  (JNICALL *CallStaticDoubleMethodV)
-  (JNIEnv*, jclass, jmethodID, va_list);
+  jmethodID(JNICALL* GetStaticMethodID)(JNIEnv*,
+                                        jclass,
+                                        const char*,
+                                        const char*);
 
-  jdouble
-  (JNICALL *CallStaticDoubleMethodA)
-  (JNIEnv*, jclass, jmethodID, const jvalue*);
+  jobject(JNICALL* CallStaticObjectMethod)(JNIEnv*, jclass, jmethodID, ...);
 
-  void
-  (JNICALL *CallStaticVoidMethod)
-  (JNIEnv*, jclass, jmethodID, ...);
+  jobject(JNICALL* CallStaticObjectMethodV)(JNIEnv*,
+                                            jclass,
+                                            jmethodID,
+                                            va_list);
 
-  void
-  (JNICALL *CallStaticVoidMethodV)
-  (JNIEnv*, jclass, jmethodID, va_list);
+  jobject(JNICALL* CallStaticObjectMethodA)(JNIEnv*,
+                                            jclass,
+                                            jmethodID,
+                                            const jvalue*);
 
-  void
-  (JNICALL *CallStaticVoidMethodA)
-  (JNIEnv*, jclass, jmethodID, const jvalue*);
+  jboolean(JNICALL* CallStaticBooleanMethod)(JNIEnv*, jclass, jmethodID, ...);
 
-  jfieldID
-  (JNICALL *GetStaticFieldID)
-    (JNIEnv*, jclass, const char*, const char*);
+  jboolean(JNICALL* CallStaticBooleanMethodV)(JNIEnv*,
+                                              jclass,
+                                              jmethodID,
+                                              va_list);
 
-  jobject
-  (JNICALL *GetStaticObjectField)
-    (JNIEnv*, jclass, jfieldID);
+  jboolean(JNICALL* CallStaticBooleanMethodA)(JNIEnv*,
+                                              jclass,
+                                              jmethodID,
+                                              const jvalue*);
 
-  jboolean
-  (JNICALL *GetStaticBooleanField)
-    (JNIEnv*, jclass, jfieldID);
+  jbyte(JNICALL* CallStaticByteMethod)(JNIEnv*, jclass, jmethodID, ...);
 
-  jbyte
-  (JNICALL *GetStaticByteField)
-    (JNIEnv*, jclass, jfieldID);
+  jbyte(JNICALL* CallStaticByteMethodV)(JNIEnv*, jclass, jmethodID, va_list);
 
-  jchar
-  (JNICALL *GetStaticCharField)
-    (JNIEnv*, jclass, jfieldID);
+  jbyte(JNICALL* CallStaticByteMethodA)(JNIEnv*,
+                                        jclass,
+                                        jmethodID,
+                                        const jvalue*);
 
-  jshort
-  (JNICALL *GetStaticShortField)
-    (JNIEnv*, jclass, jfieldID);
+  jchar(JNICALL* CallStaticCharMethod)(JNIEnv*, jclass, jmethodID, ...);
 
-  jint
-  (JNICALL *GetStaticIntField)
-    (JNIEnv*, jclass, jfieldID);
+  jchar(JNICALL* CallStaticCharMethodV)(JNIEnv*, jclass, jmethodID, va_list);
 
-  jlong
-  (JNICALL *GetStaticLongField)
-    (JNIEnv*, jclass, jfieldID);
+  jchar(JNICALL* CallStaticCharMethodA)(JNIEnv*,
+                                        jclass,
+                                        jmethodID,
+                                        const jvalue*);
 
-  jfloat
-  (JNICALL *GetStaticFloatField)
-  (JNIEnv*, jclass, jfieldID);
+  jshort(JNICALL* CallStaticShortMethod)(JNIEnv*, jclass, jmethodID, ...);
 
-  jdouble
-  (JNICALL *GetStaticDoubleField)
-  (JNIEnv*, jclass, jfieldID);
+  jshort(JNICALL* CallStaticShortMethodV)(JNIEnv*, jclass, jmethodID, va_list);
 
-  void
-  (JNICALL *SetStaticObjectField)
-  (JNIEnv*, jclass, jfieldID, jobject);
+  jshort(JNICALL* CallStaticShortMethodA)(JNIEnv*,
+                                          jclass,
+                                          jmethodID,
+                                          const jvalue*);
 
-  void
-  (JNICALL *SetStaticBooleanField)
-  (JNIEnv*, jclass, jfieldID, jboolean);
+  jint(JNICALL* CallStaticIntMethod)(JNIEnv*, jclass, jmethodID, ...);
 
-  void
-  (JNICALL *SetStaticByteField)
-  (JNIEnv*, jclass, jfieldID, jbyte);
+  jint(JNICALL* CallStaticIntMethodV)(JNIEnv*, jclass, jmethodID, va_list);
 
-  void
-  (JNICALL *SetStaticCharField)
-  (JNIEnv*, jclass, jfieldID, jchar);
+  jint(JNICALL* CallStaticIntMethodA)(JNIEnv*,
+                                      jclass,
+                                      jmethodID,
+                                      const jvalue*);
 
-  void
-  (JNICALL *SetStaticShortField)
-  (JNIEnv*, jclass, jfieldID, jshort);
+  jlong(JNICALL* CallStaticLongMethod)(JNIEnv*, jclass, jmethodID, ...);
 
-  void
-  (JNICALL *SetStaticIntField)
-  (JNIEnv*, jclass, jfieldID, jint);
+  jlong(JNICALL* CallStaticLongMethodV)(JNIEnv*, jclass, jmethodID, va_list);
 
-  void
-  (JNICALL *SetStaticLongField)
-  (JNIEnv*, jclass, jfieldID, jlong);
+  jlong(JNICALL* CallStaticLongMethodA)(JNIEnv*,
+                                        jclass,
+                                        jmethodID,
+                                        const jvalue*);
 
-  void
-  (JNICALL *SetStaticFloatField)
-  (JNIEnv*, jclass, jfieldID, jfloat);
+  jfloat(JNICALL* CallStaticFloatMethod)(JNIEnv*, jclass, jmethodID, ...);
 
-  void
-  (JNICALL *SetStaticDoubleField)
-  (JNIEnv*, jclass, jfieldID, jdouble);
+  jfloat(JNICALL* CallStaticFloatMethodV)(JNIEnv*, jclass, jmethodID, va_list);
 
-  jstring
-  (JNICALL *NewString)
-    (JNIEnv*, const jchar*, jsize);
+  jfloat(JNICALL* CallStaticFloatMethodA)(JNIEnv*,
+                                          jclass,
+                                          jmethodID,
+                                          const jvalue*);
 
-  jsize
-  (JNICALL *GetStringLength)
-    (JNIEnv*, jstring);
+  jdouble(JNICALL* CallStaticDoubleMethod)(JNIEnv*, jclass, jmethodID, ...);
 
-  const jchar*
-  (JNICALL *GetStringChars)
-  (JNIEnv*, jstring, jboolean*);
+  jdouble(JNICALL* CallStaticDoubleMethodV)(JNIEnv*,
+                                            jclass,
+                                            jmethodID,
+                                            va_list);
 
-  void
-  (JNICALL *ReleaseStringChars)
-  (JNIEnv*, jstring, const jchar*);
+  jdouble(JNICALL* CallStaticDoubleMethodA)(JNIEnv*,
+                                            jclass,
+                                            jmethodID,
+                                            const jvalue*);
 
-  jstring
-  (JNICALL *NewStringUTF)
-    (JNIEnv*, const char*);
+  void(JNICALL* CallStaticVoidMethod)(JNIEnv*, jclass, jmethodID, ...);
 
-  jsize
-  (JNICALL *GetStringUTFLength)
-    (JNIEnv*, jstring);
+  void(JNICALL* CallStaticVoidMethodV)(JNIEnv*, jclass, jmethodID, va_list);
 
-  const char*
-  (JNICALL *GetStringUTFChars)
-  (JNIEnv*, jstring, jboolean*);
+  void(JNICALL* CallStaticVoidMethodA)(JNIEnv*,
+                                       jclass,
+                                       jmethodID,
+                                       const jvalue*);
 
-  void
-  (JNICALL *ReleaseStringUTFChars)
-  (JNIEnv*, jstring, const char*);
+  jfieldID(JNICALL* GetStaticFieldID)(JNIEnv*,
+                                      jclass,
+                                      const char*,
+                                      const char*);
 
-  jsize
-  (JNICALL *GetArrayLength)
-    (JNIEnv*, jarray);
+  jobject(JNICALL* GetStaticObjectField)(JNIEnv*, jclass, jfieldID);
 
-  jobjectArray
-  (JNICALL *NewObjectArray)
-    (JNIEnv*, jsize, jclass, jobject);
+  jboolean(JNICALL* GetStaticBooleanField)(JNIEnv*, jclass, jfieldID);
 
-  jobject
-  (JNICALL *GetObjectArrayElement)
-    (JNIEnv*, jobjectArray, jsize);
+  jbyte(JNICALL* GetStaticByteField)(JNIEnv*, jclass, jfieldID);
 
-  void
-  (JNICALL *SetObjectArrayElement)
-  (JNIEnv*, jobjectArray, jsize, jobject);
+  jchar(JNICALL* GetStaticCharField)(JNIEnv*, jclass, jfieldID);
 
-  jbooleanArray
-  (JNICALL *NewBooleanArray)
-    (JNIEnv*, jsize);
+  jshort(JNICALL* GetStaticShortField)(JNIEnv*, jclass, jfieldID);
 
-  jbyteArray
-  (JNICALL *NewByteArray)
-    (JNIEnv*, jsize);
+  jint(JNICALL* GetStaticIntField)(JNIEnv*, jclass, jfieldID);
 
-  jcharArray
-  (JNICALL *NewCharArray)
-    (JNIEnv*, jsize);
+  jlong(JNICALL* GetStaticLongField)(JNIEnv*, jclass, jfieldID);
 
-  jshortArray
-  (JNICALL *NewShortArray)
-    (JNIEnv*, jsize);
+  jfloat(JNICALL* GetStaticFloatField)(JNIEnv*, jclass, jfieldID);
 
-  jintArray
-  (JNICALL *NewIntArray)
-    (JNIEnv*, jsize);
+  jdouble(JNICALL* GetStaticDoubleField)(JNIEnv*, jclass, jfieldID);
 
-  jlongArray
-  (JNICALL *NewLongArray)
-    (JNIEnv*, jsize);
+  void(JNICALL* SetStaticObjectField)(JNIEnv*, jclass, jfieldID, jobject);
 
-  jfloatArray
-  (JNICALL *NewFloatArray)
-    (JNIEnv*, jsize);
+  void(JNICALL* SetStaticBooleanField)(JNIEnv*, jclass, jfieldID, jboolean);
 
-  jdoubleArray
-  (JNICALL *NewDoubleArray)
-    (JNIEnv*, jsize);
+  void(JNICALL* SetStaticByteField)(JNIEnv*, jclass, jfieldID, jbyte);
 
-  jboolean*
-  (JNICALL *GetBooleanArrayElements)
-  (JNIEnv*, jbooleanArray, jboolean*);
+  void(JNICALL* SetStaticCharField)(JNIEnv*, jclass, jfieldID, jchar);
 
-  jbyte*
-  (JNICALL *GetByteArrayElements)
-  (JNIEnv*, jbyteArray, jboolean*);
+  void(JNICALL* SetStaticShortField)(JNIEnv*, jclass, jfieldID, jshort);
 
-  jchar*
-  (JNICALL *GetCharArrayElements)
-  (JNIEnv*, jcharArray, jboolean*);
+  void(JNICALL* SetStaticIntField)(JNIEnv*, jclass, jfieldID, jint);
 
-  jshort*
-  (JNICALL *GetShortArrayElements)
-  (JNIEnv*, jshortArray, jboolean*);
+  void(JNICALL* SetStaticLongField)(JNIEnv*, jclass, jfieldID, jlong);
 
-  jint*
-  (JNICALL *GetIntArrayElements)
-  (JNIEnv*, jintArray, jboolean*);
+  void(JNICALL* SetStaticFloatField)(JNIEnv*, jclass, jfieldID, jfloat);
 
-  jlong*
-  (JNICALL *GetLongArrayElements)
-  (JNIEnv*, jlongArray, jboolean*);
+  void(JNICALL* SetStaticDoubleField)(JNIEnv*, jclass, jfieldID, jdouble);
 
-  jfloat*
-  (JNICALL *GetFloatArrayElements)
-  (JNIEnv*, jfloatArray, jboolean*);
+  jstring(JNICALL* NewString)(JNIEnv*, const jchar*, jsize);
 
-  jdouble*
-  (JNICALL *GetDoubleArrayElements)
-  (JNIEnv*, jdoubleArray, jboolean*);
+  jsize(JNICALL* GetStringLength)(JNIEnv*, jstring);
 
-  void
-  (JNICALL *ReleaseBooleanArrayElements)
-  (JNIEnv*, jbooleanArray, jboolean*, jint);
+  const jchar*(JNICALL* GetStringChars)(JNIEnv*, jstring, jboolean*);
 
-  void
-  (JNICALL *ReleaseByteArrayElements)
-  (JNIEnv*, jbyteArray, jbyte*, jint);
+  void(JNICALL* ReleaseStringChars)(JNIEnv*, jstring, const jchar*);
 
-  void
-  (JNICALL *ReleaseCharArrayElements)
-  (JNIEnv*, jcharArray, jchar*, jint);
+  jstring(JNICALL* NewStringUTF)(JNIEnv*, const char*);
 
-  void
-  (JNICALL *ReleaseShortArrayElements)
-  (JNIEnv*, jshortArray, jshort*, jint);
+  jsize(JNICALL* GetStringUTFLength)(JNIEnv*, jstring);
 
-  void
-  (JNICALL *ReleaseIntArrayElements)
-  (JNIEnv*, jintArray, jint*, jint);
+  const char*(JNICALL* GetStringUTFChars)(JNIEnv*, jstring, jboolean*);
 
-  void
-  (JNICALL *ReleaseLongArrayElements)
-  (JNIEnv*, jlongArray, jlong*, jint);
+  void(JNICALL* ReleaseStringUTFChars)(JNIEnv*, jstring, const char*);
 
-  void
-  (JNICALL *ReleaseFloatArrayElements)
-  (JNIEnv*, jfloatArray, jfloat*, jint);
+  jsize(JNICALL* GetArrayLength)(JNIEnv*, jarray);
 
-  void
-  (JNICALL *ReleaseDoubleArrayElements)
-  (JNIEnv*, jdoubleArray, jdouble*, jint);
+  jobjectArray(JNICALL* NewObjectArray)(JNIEnv*, jsize, jclass, jobject);
 
-  void
-  (JNICALL *GetBooleanArrayRegion)
-  (JNIEnv*, jbooleanArray, jsize, jsize, jboolean*);
+  jobject(JNICALL* GetObjectArrayElement)(JNIEnv*, jobjectArray, jsize);
 
-  void
-  (JNICALL *GetByteArrayRegion)
-  (JNIEnv*, jbyteArray, jsize, jsize, jbyte*);
+  void(JNICALL* SetObjectArrayElement)(JNIEnv*, jobjectArray, jsize, jobject);
 
-  void
-  (JNICALL *GetCharArrayRegion)
-  (JNIEnv*, jcharArray, jsize, jsize, jchar*);
+  jbooleanArray(JNICALL* NewBooleanArray)(JNIEnv*, jsize);
 
-  void
-  (JNICALL *GetShortArrayRegion)
-  (JNIEnv*, jshortArray, jsize, jsize, jshort*);
+  jbyteArray(JNICALL* NewByteArray)(JNIEnv*, jsize);
 
-  void
-  (JNICALL *GetIntArrayRegion)
-  (JNIEnv*, jintArray, jsize, jsize, jint*);
+  jcharArray(JNICALL* NewCharArray)(JNIEnv*, jsize);
 
-  void
-  (JNICALL *GetLongArrayRegion)
-  (JNIEnv*, jlongArray, jsize, jsize, jlong*);
+  jshortArray(JNICALL* NewShortArray)(JNIEnv*, jsize);
 
-  void
-  (JNICALL *GetFloatArrayRegion)
-  (JNIEnv*, jfloatArray, jsize, jsize, jfloat*);
+  jintArray(JNICALL* NewIntArray)(JNIEnv*, jsize);
 
-  void
-  (JNICALL *GetDoubleArrayRegion)
-  (JNIEnv*, jdoubleArray, jsize, jsize, jdouble*);
+  jlongArray(JNICALL* NewLongArray)(JNIEnv*, jsize);
 
-  void
-  (JNICALL *SetBooleanArrayRegion)
-  (JNIEnv*, jbooleanArray, jsize, jsize, const jboolean*);
+  jfloatArray(JNICALL* NewFloatArray)(JNIEnv*, jsize);
 
-  void
-  (JNICALL *SetByteArrayRegion)
-  (JNIEnv*, jbyteArray, jsize, jsize, const jbyte*);
+  jdoubleArray(JNICALL* NewDoubleArray)(JNIEnv*, jsize);
 
-  void
-  (JNICALL *SetCharArrayRegion)
-  (JNIEnv*, jcharArray, jsize, jsize, const jchar*);
+  jboolean*(JNICALL* GetBooleanArrayElements)(JNIEnv*,
+                                              jbooleanArray,
+                                              jboolean*);
 
-  void
-  (JNICALL *SetShortArrayRegion)
-  (JNIEnv*, jshortArray, jsize, jsize, const jshort*);
+  jbyte*(JNICALL* GetByteArrayElements)(JNIEnv*, jbyteArray, jboolean*);
 
-  void
-  (JNICALL *SetIntArrayRegion)
-  (JNIEnv*, jintArray, jsize, jsize, const jint*);
+  jchar*(JNICALL* GetCharArrayElements)(JNIEnv*, jcharArray, jboolean*);
 
-  void
-  (JNICALL *SetLongArrayRegion)
-  (JNIEnv*, jlongArray, jsize, jsize, const jlong*);
+  jshort*(JNICALL* GetShortArrayElements)(JNIEnv*, jshortArray, jboolean*);
 
-  void
-  (JNICALL *SetFloatArrayRegion)
-  (JNIEnv*, jfloatArray, jsize, jsize, const jfloat*);
+  jint*(JNICALL* GetIntArrayElements)(JNIEnv*, jintArray, jboolean*);
 
-  void
-  (JNICALL *SetDoubleArrayRegion)
-  (JNIEnv*, jdoubleArray, jsize, jsize, const jdouble*);
+  jlong*(JNICALL* GetLongArrayElements)(JNIEnv*, jlongArray, jboolean*);
 
-  jint
-  (JNICALL *RegisterNatives)
-    (JNIEnv*, jclass, const JNINativeMethod*, jint);
+  jfloat*(JNICALL* GetFloatArrayElements)(JNIEnv*, jfloatArray, jboolean*);
 
-  jint
-  (JNICALL *UnregisterNatives)
-    (JNIEnv*, jclass);
+  jdouble*(JNICALL* GetDoubleArrayElements)(JNIEnv*, jdoubleArray, jboolean*);
 
-  jint
-  (JNICALL *MonitorEnter)
-    (JNIEnv*, jobject);
+  void(JNICALL* ReleaseBooleanArrayElements)(JNIEnv*,
+                                             jbooleanArray,
+                                             jboolean*,
+                                             jint);
 
-  jint
-  (JNICALL *MonitorExit)
-    (JNIEnv*, jobject);
+  void(JNICALL* ReleaseByteArrayElements)(JNIEnv*, jbyteArray, jbyte*, jint);
 
-  jint
-  (JNICALL *GetJavaVM)
-    (JNIEnv*, JavaVM**);
+  void(JNICALL* ReleaseCharArrayElements)(JNIEnv*, jcharArray, jchar*, jint);
 
-  void
-  (JNICALL *GetStringRegion)
-  (JNIEnv*, jstring, jsize, jsize, jchar*);
+  void(JNICALL* ReleaseShortArrayElements)(JNIEnv*, jshortArray, jshort*, jint);
 
-  void
-  (JNICALL *GetStringUTFRegion)
-  (JNIEnv*, jstring, jsize, jsize, char*);
+  void(JNICALL* ReleaseIntArrayElements)(JNIEnv*, jintArray, jint*, jint);
 
-  void*
-  (JNICALL *GetPrimitiveArrayCritical)
-  (JNIEnv*, jarray, jboolean*);
+  void(JNICALL* ReleaseLongArrayElements)(JNIEnv*, jlongArray, jlong*, jint);
 
-  void
-  (JNICALL *ReleasePrimitiveArrayCritical)
-  (JNIEnv*, jarray, void*, jint);
+  void(JNICALL* ReleaseFloatArrayElements)(JNIEnv*, jfloatArray, jfloat*, jint);
 
-  const jchar*
-  (JNICALL *GetStringCritical)
-  (JNIEnv*, jstring, jboolean*);
+  void(JNICALL* ReleaseDoubleArrayElements)(JNIEnv*,
+                                            jdoubleArray,
+                                            jdouble*,
+                                            jint);
 
-  void
-  (JNICALL *ReleaseStringCritical)
-  (JNIEnv*, jstring, const jchar*);
+  void(JNICALL* GetBooleanArrayRegion)(JNIEnv*,
+                                       jbooleanArray,
+                                       jsize,
+                                       jsize,
+                                       jboolean*);
 
-  jweak
-  (JNICALL *NewWeakGlobalRef)
-  (JNIEnv*, jobject);
+  void(JNICALL* GetByteArrayRegion)(JNIEnv*, jbyteArray, jsize, jsize, jbyte*);
 
-  void
-  (JNICALL *DeleteWeakGlobalRef)
-  (JNIEnv*, jweak);
+  void(JNICALL* GetCharArrayRegion)(JNIEnv*, jcharArray, jsize, jsize, jchar*);
 
-  jboolean
-  (JNICALL *ExceptionCheck)
-    (JNIEnv*);
+  void(JNICALL* GetShortArrayRegion)(JNIEnv*,
+                                     jshortArray,
+                                     jsize,
+                                     jsize,
+                                     jshort*);
 
-  jobject
-  (JNICALL *NewDirectByteBuffer)
-    (JNIEnv*, void*, jlong);
+  void(JNICALL* GetIntArrayRegion)(JNIEnv*, jintArray, jsize, jsize, jint*);
 
-  void*
-  (JNICALL *GetDirectBufferAddress)
-  (JNIEnv* env, jobject);
+  void(JNICALL* GetLongArrayRegion)(JNIEnv*, jlongArray, jsize, jsize, jlong*);
 
-  jlong
-  (JNICALL *GetDirectBufferCapacity)
-    (JNIEnv*, jobject);
+  void(JNICALL* GetFloatArrayRegion)(JNIEnv*,
+                                     jfloatArray,
+                                     jsize,
+                                     jsize,
+                                     jfloat*);
 
+  void(JNICALL* GetDoubleArrayRegion)(JNIEnv*,
+                                      jdoubleArray,
+                                      jsize,
+                                      jsize,
+                                      jdouble*);
+
+  void(JNICALL* SetBooleanArrayRegion)(JNIEnv*,
+                                       jbooleanArray,
+                                       jsize,
+                                       jsize,
+                                       const jboolean*);
+
+  void(JNICALL* SetByteArrayRegion)(JNIEnv*,
+                                    jbyteArray,
+                                    jsize,
+                                    jsize,
+                                    const jbyte*);
+
+  void(JNICALL* SetCharArrayRegion)(JNIEnv*,
+                                    jcharArray,
+                                    jsize,
+                                    jsize,
+                                    const jchar*);
+
+  void(JNICALL* SetShortArrayRegion)(JNIEnv*,
+                                     jshortArray,
+                                     jsize,
+                                     jsize,
+                                     const jshort*);
+
+  void(JNICALL* SetIntArrayRegion)(JNIEnv*,
+                                   jintArray,
+                                   jsize,
+                                   jsize,
+                                   const jint*);
+
+  void(JNICALL* SetLongArrayRegion)(JNIEnv*,
+                                    jlongArray,
+                                    jsize,
+                                    jsize,
+                                    const jlong*);
+
+  void(JNICALL* SetFloatArrayRegion)(JNIEnv*,
+                                     jfloatArray,
+                                     jsize,
+                                     jsize,
+                                     const jfloat*);
+
+  void(JNICALL* SetDoubleArrayRegion)(JNIEnv*,
+                                      jdoubleArray,
+                                      jsize,
+                                      jsize,
+                                      const jdouble*);
+
+  jint(JNICALL* RegisterNatives)(JNIEnv*, jclass, const JNINativeMethod*, jint);
+
+  jint(JNICALL* UnregisterNatives)(JNIEnv*, jclass);
+
+  jint(JNICALL* MonitorEnter)(JNIEnv*, jobject);
+
+  jint(JNICALL* MonitorExit)(JNIEnv*, jobject);
+
+  jint(JNICALL* GetJavaVM)(JNIEnv*, JavaVM**);
+
+  void(JNICALL* GetStringRegion)(JNIEnv*, jstring, jsize, jsize, jchar*);
+
+  void(JNICALL* GetStringUTFRegion)(JNIEnv*, jstring, jsize, jsize, char*);
+
+  void*(JNICALL* GetPrimitiveArrayCritical)(JNIEnv*, jarray, jboolean*);
+
+  void(JNICALL* ReleasePrimitiveArrayCritical)(JNIEnv*, jarray, void*, jint);
+
+  const jchar*(JNICALL* GetStringCritical)(JNIEnv*, jstring, jboolean*);
+
+  void(JNICALL* ReleaseStringCritical)(JNIEnv*, jstring, const jchar*);
+
+  jweak(JNICALL* NewWeakGlobalRef)(JNIEnv*, jobject);
+
+  void(JNICALL* DeleteWeakGlobalRef)(JNIEnv*, jweak);
+
+  jboolean(JNICALL* ExceptionCheck)(JNIEnv*);
+
+  jobject(JNICALL* NewDirectByteBuffer)(JNIEnv*, void*, jlong);
+
+  void*(JNICALL* GetDirectBufferAddress)(JNIEnv* env, jobject);
+
+  jlong(JNICALL* GetDirectBufferCapacity)(JNIEnv*, jobject);
 };
 
-inline void
-atomicOr(uint32_t* p, int v)
+inline void atomicOr(uint32_t* p, int v)
 {
-  for (uint32_t old = *p;
-       not atomicCompareAndSwap32(p, old, old | v);
-       old = *p)
-  { }
+  for (uint32_t old = *p; not atomicCompareAndSwap32(p, old, old | v);
+       old = *p) {
+  }
 }
 
-inline void
-atomicAnd(uint32_t* p, int v)
+inline void atomicAnd(uint32_t* p, int v)
 {
-  for (uint32_t old = *p;
-       not atomicCompareAndSwap32(p, old, old & v);
-       old = *p)
-  { }
+  for (uint32_t old = *p; not atomicCompareAndSwap32(p, old, old & v);
+       old = *p) {
+  }
 }
 
-inline int
-strcmp(const int8_t* a, const int8_t* b)
+inline int strcmp(const int8_t* a, const int8_t* b)
 {
   return ::strcmp(reinterpret_cast<const char*>(a),
                   reinterpret_cast<const char*>(b));
 }
 
-void
-noop();
+void noop();
 
 class Reference {
  public:
-  Reference(object target, Reference** handle, bool weak):
-    target(target),
-    next(*handle),
-    handle(handle),
-    count(0),
-    weak(weak)
+  Reference(object target, Reference** handle, bool weak)
+      : target(target), next(*handle), handle(handle), count(0), weak(weak)
   {
     if (next) {
       next->handle = &next;
@@ -1220,10 +996,17 @@ class Machine {
     ImmortalAllocation
   };
 
-  Machine(System* system, Heap* heap, Finder* bootFinder, Finder* appFinder,
-          Processor* processor, Classpath* classpath, const char** properties,
-          unsigned propertyCount, const char** arguments,
-          unsigned argumentCount, unsigned stackSizeInBytes);
+  Machine(System* system,
+          Heap* heap,
+          Finder* bootFinder,
+          Finder* appFinder,
+          Processor* processor,
+          Classpath* classpath,
+          const char** properties,
+          unsigned propertyCount,
+          const char** arguments,
+          unsigned argumentCount,
+          unsigned stackSizeInBytes);
 
   ~Machine()
   {
@@ -1284,37 +1067,33 @@ class Machine {
 
 void printTrace(Thread* t, GcThrowable* exception);
 
-void
-enterActiveState(Thread* t);
+void enterActiveState(Thread* t);
 
 #ifdef VM_STRESS
 
 inline void stress(Thread* t);
 
-#else // not VM_STRESS
+#else  // not VM_STRESS
 
 #define stress(t)
 
-#endif // not VM_STRESS
+#endif  // not VM_STRESS
 
-uint64_t
-runThread(Thread*, uintptr_t*);
+uint64_t runThread(Thread*, uintptr_t*);
 
-uint64_t
-run(Thread* t, uint64_t (*function)(Thread*, uintptr_t*),
-    uintptr_t* arguments);
+uint64_t run(Thread* t,
+             uint64_t (*function)(Thread*, uintptr_t*),
+             uintptr_t* arguments);
 
-void
-checkDaemon(Thread* t);
+void checkDaemon(Thread* t);
 
 GcRoots* roots(Thread* t);
 
-extern "C" uint64_t
-vmRun(uint64_t (*function)(Thread*, uintptr_t*), uintptr_t* arguments,
-      void* checkpoint);
+extern "C" uint64_t vmRun(uint64_t (*function)(Thread*, uintptr_t*),
+                          uintptr_t* arguments,
+                          void* checkpoint);
 
-extern "C" void
-vmRun_returnAddress();
+extern "C" void vmRun_returnAddress();
 
 class GcThread;
 class GcThrowable;
@@ -1343,11 +1122,13 @@ class Thread {
 
   class Protector {
    public:
-    Protector(Thread* t): t(t), next(t->protector) {
+    Protector(Thread* t) : t(t), next(t->protector)
+    {
       t->protector = this;
     }
 
-    ~Protector() {
+    ~Protector()
+    {
       t->protector = next;
     }
 
@@ -1357,13 +1138,14 @@ class Thread {
     Protector* next;
   };
 
-  class SingleProtector: public Protector {
+  class SingleProtector : public Protector {
    public:
     SingleProtector(Thread* t, void* p) : Protector(t), p(p)
     {
     }
 
-    virtual void visit(Heap::Visitor* v) {
+    virtual void visit(Heap::Visitor* v)
+    {
       v->visit(p);
     }
 
@@ -1372,7 +1154,8 @@ class Thread {
 
   class Resource {
    public:
-    Resource(Thread* t, Resource* next): t(t), next(next) {
+    Resource(Thread* t, Resource* next) : t(t), next(next)
+    {
       t->resource = this;
     }
 
@@ -1382,19 +1165,21 @@ class Thread {
     Resource* next;
   };
 
-  class AutoResource: public Resource {
+  class AutoResource : public Resource {
    public:
-    AutoResource(Thread* t): Resource(t, t->resource) { }
+    AutoResource(Thread* t) : Resource(t, t->resource)
+    {
+    }
 
-    ~AutoResource() {
+    ~AutoResource()
+    {
       t->resource = next;
     }
 
     virtual void release() = 0;
-
   };
 
-  class ClassInitStack: public AutoResource {
+  class ClassInitStack : public AutoResource {
    public:
     ClassInitStack(Thread* t, GcClass* class_)
         : AutoResource(t),
@@ -1405,11 +1190,13 @@ class Thread {
       t->classInitStack = this;
     }
 
-    ~ClassInitStack() {
+    ~ClassInitStack()
+    {
       t->classInitStack = next;
     }
 
-    virtual void release() {
+    virtual void release()
+    {
       this->ClassInitStack::~ClassInitStack();
     }
 
@@ -1418,7 +1205,7 @@ class Thread {
     SingleProtector protector;
   };
 
-  class LibraryLoadStack: public AutoResource {
+  class LibraryLoadStack : public AutoResource {
    public:
     LibraryLoadStack(Thread* t, GcClassLoader* classLoader)
         : AutoResource(t),
@@ -1429,11 +1216,13 @@ class Thread {
       t->libraryLoadStack = this;
     }
 
-    ~LibraryLoadStack() {
+    ~LibraryLoadStack()
+    {
       t->libraryLoadStack = next;
     }
 
-    virtual void release() {
+    virtual void release()
+    {
       this->LibraryLoadStack::~LibraryLoadStack();
     }
 
@@ -1444,17 +1233,18 @@ class Thread {
 
   class Checkpoint {
    public:
-    Checkpoint(Thread* t):
-      t(t),
-      next(t->checkpoint),
-      resource(t->resource),
-      protector(t->protector),
-      noThrow(false)
+    Checkpoint(Thread* t)
+        : t(t),
+          next(t->checkpoint),
+          resource(t->resource),
+          protector(t->protector),
+          noThrow(false)
     {
       t->checkpoint = this;
     }
 
-    ~Checkpoint() {
+    ~Checkpoint()
+    {
       t->checkpoint = next;
     }
 
@@ -1467,14 +1257,14 @@ class Thread {
     bool noThrow;
   };
 
-  class RunCheckpoint: public Checkpoint {
+  class RunCheckpoint : public Checkpoint {
    public:
-    RunCheckpoint(Thread* t):
-      Checkpoint(t),
-      stack(0)
-    { }
+    RunCheckpoint(Thread* t) : Checkpoint(t), stack(0)
+    {
+    }
 
-    virtual void unwind() {
+    virtual void unwind()
+    {
       void* stack = this->stack;
       this->stack = 0;
       expect(t->m->system, stack);
@@ -1484,11 +1274,14 @@ class Thread {
     void* stack;
   };
 
-  class Runnable: public System::Runnable {
+  class Runnable : public System::Runnable {
    public:
-    Runnable(Thread* t): t(t) { }
+    Runnable(Thread* t) : t(t)
+    {
+    }
 
-    virtual void attach(System::Thread* st) {
+    virtual void attach(System::Thread* st)
+    {
       t->systemThread = st;
     }
 
@@ -1555,36 +1348,27 @@ class Classpath {
 
   virtual GcField* getVMField(Thread* t, GcJfield* jfield) = 0;
 
-  virtual void
-  clearInterrupted(Thread* t) = 0;
+  virtual void clearInterrupted(Thread* t) = 0;
 
-  virtual void
-  runThread(Thread* t) = 0;
+  virtual void runThread(Thread* t) = 0;
 
   virtual void resolveNative(Thread* t, GcMethod* method) = 0;
 
-  virtual void
-  interceptMethods(Thread* t) = 0;
+  virtual void interceptMethods(Thread* t) = 0;
 
-  virtual void
-  preBoot(Thread* t) = 0;
+  virtual void preBoot(Thread* t) = 0;
 
   virtual bool mayInitClasses() = 0;
 
-  virtual void
-  boot(Thread* t) = 0;
+  virtual void boot(Thread* t) = 0;
 
-  virtual const char*
-  bootClasspath() = 0;
+  virtual const char* bootClasspath() = 0;
 
-  virtual object
-  makeDirectByteBuffer(Thread* t, void* p, jlong capacity) = 0;
+  virtual object makeDirectByteBuffer(Thread* t, void* p, jlong capacity) = 0;
 
-  virtual void*
-  getDirectBufferAddress(Thread* t, object buffer) = 0;
+  virtual void* getDirectBufferAddress(Thread* t, object buffer) = 0;
 
-  virtual int64_t
-  getDirectBufferCapacity(Thread* t, object buffer) = 0;
+  virtual int64_t getDirectBufferCapacity(Thread* t, object buffer) = 0;
 
   virtual bool canTailCall(Thread* t,
                            GcMethod* caller,
@@ -1594,29 +1378,30 @@ class Classpath {
 
   virtual GcClassLoader* libraryClassLoader(Thread* t, GcMethod* caller) = 0;
 
-  virtual void
-  shutDown(Thread* t) = 0;
+  virtual void shutDown(Thread* t) = 0;
 
-  virtual void
-  dispose() = 0;
+  virtual void dispose() = 0;
 };
 
 #ifdef _MSC_VER
 
 template <class T>
-class ThreadRuntimeArray: public Thread::AutoResource {
+class ThreadRuntimeArray : public Thread::AutoResource {
  public:
-  ThreadRuntimeArray(Thread* t, unsigned size):
-    AutoResource(t),
-    body(static_cast<T*>(t->m->heap->allocate(size * sizeof(T)))),
-    size(size)
-  { }
+  ThreadRuntimeArray(Thread* t, unsigned size)
+      : AutoResource(t),
+        body(static_cast<T*>(t->m->heap->allocate(size * sizeof(T)))),
+        size(size)
+  {
+  }
 
-  ~ThreadRuntimeArray() {
+  ~ThreadRuntimeArray()
+  {
     t->m->heap->free(body, size * sizeof(T));
   }
 
-  virtual void release() {
+  virtual void release()
+  {
     ThreadRuntimeArray::~ThreadRuntimeArray();
   }
 
@@ -1624,19 +1409,19 @@ class ThreadRuntimeArray: public Thread::AutoResource {
   unsigned size;
 };
 
-#  define THREAD_RUNTIME_ARRAY(thread, type, name, size)        \
+#define THREAD_RUNTIME_ARRAY(thread, type, name, size) \
   ThreadRuntimeArray<type> name(thread, size);
 
-#else // not _MSC_VER
+#else  // not _MSC_VER
 
-#  define THREAD_RUNTIME_ARRAY(thread, type, name, size) \
-  type name##_body[size];
+#define THREAD_RUNTIME_ARRAY(thread, type, name, size) type name##_body[size];
 
-#endif // not _MSC_VER
+#endif  // not _MSC_VER
 
-Classpath*
-makeClasspath(System* system, Allocator* allocator, const char* javaHome,
-              const char* embedPrefix);
+Classpath* makeClasspath(System* system,
+                         Allocator* allocator,
+                         const char* javaHome,
+                         const char* embedPrefix);
 
 typedef uint64_t(JNICALL* FastNativeFunction)(Thread*, GcMethod*, uintptr_t*);
 
@@ -1646,32 +1431,33 @@ inline GcClass* objectClass(Thread*, object o)
       maskAlignedPointer(fieldAtOffset<object>(o, 0)));
 }
 
-inline unsigned
-stackSizeInWords(Thread* t)
+inline unsigned stackSizeInWords(Thread* t)
 {
   return t->m->stackSizeInBytes / BytesPerWord;
 }
 
-void
-enter(Thread* t, Thread::State state);
+void enter(Thread* t, Thread::State state);
 
-inline void
-enterActiveState(Thread* t)
+inline void enterActiveState(Thread* t)
 {
   enter(t, Thread::ActiveState);
 }
 
-class StateResource: public Thread::AutoResource {
+class StateResource : public Thread::AutoResource {
  public:
-  StateResource(Thread* t, Thread::State state):
-    AutoResource(t), oldState(t->state)
+  StateResource(Thread* t, Thread::State state)
+      : AutoResource(t), oldState(t->state)
   {
     enter(t, state);
   }
 
-  ~StateResource() { enter(t, oldState); }
+  ~StateResource()
+  {
+    enter(t, oldState);
+  }
 
-  virtual void release() {
+  virtual void release()
+  {
     this->StateResource::~StateResource();
   }
 
@@ -1679,8 +1465,7 @@ class StateResource: public Thread::AutoResource {
   Thread::State oldState;
 };
 
-inline void
-dispose(Thread* t, Reference* r)
+inline void dispose(Thread* t, Reference* r)
 {
   *(r->handle) = r->next;
   if (r->next) {
@@ -1689,52 +1474,44 @@ dispose(Thread* t, Reference* r)
   t->m->heap->free(r, sizeof(*r));
 }
 
-inline void
-acquire(Thread*, Reference* r)
+inline void acquire(Thread*, Reference* r)
 {
-  ++ r->count;
+  ++r->count;
 }
 
-inline void
-release(Thread* t, Reference* r)
+inline void release(Thread* t, Reference* r)
 {
-  if ((-- r->count) == 0) {
+  if ((--r->count) == 0) {
     dispose(t, r);
   }
 }
 
-void
-collect(Thread* t, Heap::CollectionType type, int pendingAllocation = 0);
+void collect(Thread* t, Heap::CollectionType type, int pendingAllocation = 0);
 
-void
-shutDown(Thread* t);
+void shutDown(Thread* t);
 
 #ifdef VM_STRESS
 
-inline void
-stress(Thread* t)
+inline void stress(Thread* t)
 {
   if ((not t->m->unsafe)
       and (t->flags & (Thread::StressFlag | Thread::TracingFlag)) == 0
-      and t->state != Thread::NoState
-      and t->state != Thread::IdleState)
-  {
+      and t->state != Thread::NoState and t->state != Thread::IdleState) {
     atomicOr(&(t->flags), Thread::StressFlag);
 
-#  ifdef VM_STRESS_MAJOR
+#ifdef VM_STRESS_MAJOR
     collect(t, Heap::MajorCollection);
-#  else // not VM_STRESS_MAJOR
+#else   // not VM_STRESS_MAJOR
     collect(t, Heap::MinorCollection);
-#  endif // not VM_STRESS_MAJOR
+#endif  // not VM_STRESS_MAJOR
 
     atomicAnd(&(t->flags), ~Thread::StressFlag);
   }
 }
 
-#endif // not VM_STRESS
+#endif  // not VM_STRESS
 
-inline void
-acquire(Thread* t, System::Monitor* m)
+inline void acquire(Thread* t, System::Monitor* m)
 {
   if (not m->tryAcquire(t->systemThread)) {
     ENTER(t, Thread::IdleState);
@@ -1744,25 +1521,25 @@ acquire(Thread* t, System::Monitor* m)
   stress(t);
 }
 
-inline void
-release(Thread* t, System::Monitor* m)
+inline void release(Thread* t, System::Monitor* m)
 {
   m->release(t->systemThread);
 }
 
-class MonitorResource: public Thread::AutoResource {
+class MonitorResource : public Thread::AutoResource {
  public:
-  MonitorResource(Thread* t, System::Monitor* m):
-    AutoResource(t), m(m)
+  MonitorResource(Thread* t, System::Monitor* m) : AutoResource(t), m(m)
   {
     acquire(t, m);
   }
 
-  ~MonitorResource() {
+  ~MonitorResource()
+  {
     vm::release(t, m);
   }
 
-  virtual void release() {
+  virtual void release()
+  {
     this->MonitorResource::~MonitorResource();
   }
 
@@ -1770,20 +1547,22 @@ class MonitorResource: public Thread::AutoResource {
   System::Monitor* m;
 };
 
-class RawMonitorResource: public Thread::Resource {
+class RawMonitorResource : public Thread::Resource {
  public:
-  RawMonitorResource(Thread* t, System::Monitor* m):
-    Resource(t, t->resource), m(m)
+  RawMonitorResource(Thread* t, System::Monitor* m)
+      : Resource(t, t->resource), m(m)
   {
     m->acquire(t->systemThread);
   }
 
-  ~RawMonitorResource() {
+  ~RawMonitorResource()
+  {
     t->resource = next;
     vm::release(t, m);
   }
 
-  virtual void release() {
+  virtual void release()
+  {
     this->RawMonitorResource::~RawMonitorResource();
   }
 
@@ -1791,16 +1570,15 @@ class RawMonitorResource: public Thread::Resource {
   System::Monitor* m;
 };
 
-inline Aborter* getAborter(Thread* t) {
+inline Aborter* getAborter(Thread* t)
+{
   return t->m->system;
 }
 
-inline bool
-ensure(Thread* t, unsigned sizeInBytes)
+inline bool ensure(Thread* t, unsigned sizeInBytes)
 {
   if (t->heapIndex + ceilingDivide(sizeInBytes, BytesPerWord)
-      > ThreadHeapSizeInWords)
-  {
+      > ThreadHeapSizeInWords) {
     if (sizeInBytes <= ThreadBackupHeapSizeInBytes) {
       expect(t, (t->flags & Thread::UseBackupHeapFlag) == 0);
 
@@ -1815,15 +1593,15 @@ ensure(Thread* t, unsigned sizeInBytes)
   }
 }
 
-object
-allocate2(Thread* t, unsigned sizeInBytes, bool objectMask);
+object allocate2(Thread* t, unsigned sizeInBytes, bool objectMask);
 
-object
-allocate3(Thread* t, Allocator* allocator, Machine::AllocationType type,
-          unsigned sizeInBytes, bool objectMask);
+object allocate3(Thread* t,
+                 Allocator* allocator,
+                 Machine::AllocationType type,
+                 unsigned sizeInBytes,
+                 bool objectMask);
 
-inline object
-allocateSmall(Thread* t, unsigned sizeInBytes)
+inline object allocateSmall(Thread* t, unsigned sizeInBytes)
 {
   assertT(t,
           t->heapIndex + ceilingDivide(sizeInBytes, BytesPerWord)
@@ -1834,15 +1612,12 @@ allocateSmall(Thread* t, unsigned sizeInBytes)
   return o;
 }
 
-inline object
-allocate(Thread* t, unsigned sizeInBytes, bool objectMask)
+inline object allocate(Thread* t, unsigned sizeInBytes, bool objectMask)
 {
   stress(t);
 
   if (UNLIKELY(t->heapIndex + ceilingDivide(sizeInBytes, BytesPerWord)
-               > ThreadHeapSizeInWords
-               or t->m->exclusive))
-  {
+               > ThreadHeapSizeInWords or t->m->exclusive)) {
     return allocate2(t, sizeInBytes, objectMask);
   } else {
     assertT(t, t->criticalLevel == 0);
@@ -1850,14 +1625,12 @@ allocate(Thread* t, unsigned sizeInBytes, bool objectMask)
   }
 }
 
-inline void
-mark(Thread* t, object o, unsigned offset, unsigned count)
+inline void mark(Thread* t, object o, unsigned offset, unsigned count)
 {
   t->m->heap->mark(o, offset / BytesPerWord, count);
 }
 
-inline void
-mark(Thread* t, object o, unsigned offset)
+inline void mark(Thread* t, object o, unsigned offset)
 {
   t->m->heap->mark(o, offset / BytesPerWord, 1);
 }
@@ -1884,15 +1657,14 @@ inline void setObjectClass(Thread*, object o, GcClass* c)
          & (~PointerMask)));
 }
 
-inline const char*
-findProperty(Machine* m, const char* name)
+inline const char* findProperty(Machine* m, const char* name)
 {
   for (unsigned i = 0; i < m->propertyCount; ++i) {
     const char* p = m->properties[i];
     const char* n = name;
     while (*p and *p != '=' and *n and *p == *n) {
-      ++ p;
-      ++ n;
+      ++p;
+      ++n;
     }
     if (*p == '=' and *n == 0) {
       return p + 1;
@@ -1901,8 +1673,7 @@ findProperty(Machine* m, const char* name)
   return 0;
 }
 
-inline const char*
-findProperty(Thread* t, const char* name)
+inline const char* findProperty(Thread* t, const char* name)
 {
   return findProperty(t->m, name);
 }
@@ -1978,32 +1749,30 @@ inline void Thread::Runnable::setInterrupted(bool v)
   t->javaThread->interrupted() = v;
 }
 
-inline uint64_t
-runRaw(Thread* t,
-       uint64_t (*function)(Thread*, uintptr_t*), uintptr_t* arguments)
+inline uint64_t runRaw(Thread* t,
+                       uint64_t (*function)(Thread*, uintptr_t*),
+                       uintptr_t* arguments)
 {
   Thread::RunCheckpoint checkpoint(t);
   return vmRun(function, arguments, &checkpoint);
 }
 
-inline uint64_t
-run(Thread* t, uint64_t (*function)(Thread*, uintptr_t*), uintptr_t* arguments)
+inline uint64_t run(Thread* t,
+                    uint64_t (*function)(Thread*, uintptr_t*),
+                    uintptr_t* arguments)
 {
   ENTER(t, Thread::ActiveState);
   return runRaw(t, function, arguments);
 }
 
-inline void
-runJavaThread(Thread* t)
+inline void runJavaThread(Thread* t)
 {
   t->m->classpath->runThread(t);
 }
 
-void
-runFinalizeThread(Thread* t);
+void runFinalizeThread(Thread* t);
 
-inline uint64_t
-runThread(Thread* t, uintptr_t*)
+inline uint64_t runThread(Thread* t, uintptr_t*)
 {
   t->m->localThread->set(t);
 
@@ -2018,24 +1787,24 @@ runThread(Thread* t, uintptr_t*)
   return 1;
 }
 
-inline bool
-startThread(Thread* t, Thread* p)
+inline bool startThread(Thread* t, Thread* p)
 {
   p->flags |= Thread::JoinFlag;
   return t->m->system->success(t->m->system->start(&(p->runnable)));
 }
 
-inline void
-addThread(Thread* t, Thread* p)
+inline void addThread(Thread* t, Thread* p)
 {
   ACQUIRE_RAW(t, t->m->stateLock);
 
   assertT(t, p->state == Thread::NoState);
-  expect(t, t->state == Thread::ActiveState || t->state == Thread::ExclusiveState || t->state == Thread::NoState);
+  expect(t,
+         t->state == Thread::ActiveState || t->state == Thread::ExclusiveState
+         || t->state == Thread::NoState);
 
   p->state = Thread::IdleState;
-  ++ t->m->threadCount;
-  ++ t->m->liveCount;
+  ++t->m->threadCount;
+  ++t->m->liveCount;
 
   p->peer = p->parent->child;
   p->parent->child = p;
@@ -2045,15 +1814,14 @@ addThread(Thread* t, Thread* p)
   }
 }
 
-inline void
-removeThread(Thread* t, Thread* p)
+inline void removeThread(Thread* t, Thread* p)
 {
   ACQUIRE_RAW(t, t->m->stateLock);
 
   assertT(t, p->state == Thread::IdleState);
 
-  -- t->m->liveCount;
-  -- t->m->threadCount;
+  --t->m->liveCount;
+  --t->m->threadCount;
 
   t->m->stateLock->notifyAll(t->systemThread);
 
@@ -2068,7 +1836,8 @@ removeThread(Thread* t, Thread* p)
 
 inline Thread* startThread(Thread* t, GcThread* javaThread)
 {
-  { PROTECT(t, javaThread);
+  {
+    PROTECT(t, javaThread);
 
     stress(t);
 
@@ -2091,28 +1860,25 @@ inline Thread* startThread(Thread* t, GcThread* javaThread)
   }
 }
 
-inline void
-registerDaemon(Thread* t)
+inline void registerDaemon(Thread* t)
 {
   ACQUIRE_RAW(t, t->m->stateLock);
 
   atomicOr(&(t->flags), Thread::DaemonFlag);
 
-  ++ t->m->daemonCount;
+  ++t->m->daemonCount;
 
   t->m->stateLock->notifyAll(t->systemThread);
 }
 
-inline void
-checkDaemon(Thread* t)
+inline void checkDaemon(Thread* t)
 {
   if (t->javaThread->daemon()) {
     registerDaemon(t);
   }
 }
 
-inline uint64_t
-initAttachedThread(Thread* t, uintptr_t* arguments)
+inline uint64_t initAttachedThread(Thread* t, uintptr_t* arguments)
 {
   bool daemon = arguments[0];
 
@@ -2131,8 +1897,7 @@ initAttachedThread(Thread* t, uintptr_t* arguments)
   return 1;
 }
 
-inline Thread*
-attachThread(Machine* m, bool daemon)
+inline Thread* attachThread(Machine* m, bool daemon)
 {
   Thread* t = m->processor->makeThread(m, 0, m->rootThread);
   m->system->attach(&(t->runnable));
@@ -2141,7 +1906,7 @@ attachThread(Machine* m, bool daemon)
 
   enter(t, Thread::ActiveState);
 
-  uintptr_t arguments[] = { daemon };
+  uintptr_t arguments[] = {daemon};
 
   if (run(t, initAttachedThread, arguments)) {
     enter(t, Thread::IdleState);
@@ -2167,20 +1932,17 @@ inline void setType(Thread* t, Gc::Type type, GcClass* value)
   t->m->types->setBodyElement(t, type, value);
 }
 
-inline bool
-objectFixed(Thread*, object o)
+inline bool objectFixed(Thread*, object o)
 {
   return (alias(o, 0) & (~PointerMask)) == FixedMark;
 }
 
-inline bool
-objectExtended(Thread*, object o)
+inline bool objectExtended(Thread*, object o)
 {
   return (alias(o, 0) & (~PointerMask)) == ExtendedMark;
 }
 
-inline bool
-hashTaken(Thread*, object o)
+inline bool hashTaken(Thread*, object o)
 {
   return (alias(o, 0) & (~PointerMask)) == HashTakenMark;
 }
@@ -2196,14 +1958,11 @@ inline unsigned baseSize(Thread* t UNUSED, object o, GcClass* class_)
                          BytesPerWord);
 }
 
-object
-makeTrace(Thread* t, Processor::StackWalker* walker);
+object makeTrace(Thread* t, Processor::StackWalker* walker);
 
-object
-makeTrace(Thread* t, Thread* target);
+object makeTrace(Thread* t, Thread* target);
 
-inline object
-makeTrace(Thread* t)
+inline object makeTrace(Thread* t)
 {
   return makeTrace(t, t);
 }
@@ -2250,14 +2009,14 @@ inline uint32_t GcString::offset(Thread*)
   return 0;
 }
 
-#  ifndef HAVE_StringHash32
+#ifndef HAVE_StringHash32
 
 inline GcString* makeString(Thread* t, object data, int32_t hash, int32_t)
 {
   return makeString(t, data, hash);
 }
 
-#  endif // not HAVE_StringHash32
+#endif  // not HAVE_StringHash32
 
 inline GcString* makeString(Thread* t,
                             object odata,
@@ -2279,7 +2038,7 @@ inline GcString* makeString(Thread* t,
   }
 }
 
-#endif // not HAVE_StringOffset
+#endif  // not HAVE_StringOffset
 
 int stringUTFLength(Thread* t,
                     GcString* string,
@@ -2332,24 +2091,20 @@ bool isAssignableFrom(Thread* t, GcClass* a, GcClass* b);
 
 GcMethod* classInitializer(Thread* t, GcClass* class_);
 
-object
-frameMethod(Thread* t, int frame);
+object frameMethod(Thread* t, int frame);
 
-inline uintptr_t&
-extendedWord(Thread* t UNUSED, object o, unsigned baseSize)
+inline uintptr_t& extendedWord(Thread* t UNUSED, object o, unsigned baseSize)
 {
   assertT(t, objectExtended(t, o));
   return fieldAtOffset<uintptr_t>(o, baseSize * BytesPerWord);
 }
 
-inline unsigned
-extendedSize(Thread* t, object o, unsigned baseSize)
+inline unsigned extendedSize(Thread* t, object o, unsigned baseSize)
 {
   return baseSize + objectExtended(t, o);
 }
 
-inline void
-markHashTaken(Thread* t, object o)
+inline void markHashTaken(Thread* t, object o)
 {
   assertT(t, not objectExtended(t, o));
   assertT(t, not objectFixed(t, o));
@@ -2360,8 +2115,7 @@ markHashTaken(Thread* t, object o)
   t->m->heap->pad(o);
 }
 
-inline uint32_t
-takeHash(Thread*, object o)
+inline uint32_t takeHash(Thread*, object o)
 {
   // some broken code implicitly relies on System.identityHashCode
   // always returning a non-negative number (e.g. old versions of
@@ -2370,8 +2124,7 @@ takeHash(Thread*, object o)
   return (reinterpret_cast<uintptr_t>(o) / BytesPerWord) & 0x7FFFFFFF;
 }
 
-inline uint32_t
-objectHash(Thread* t, object o)
+inline uint32_t objectHash(Thread* t, object o)
 {
   if (objectExtended(t, o)) {
     return extendedWord(t, o, baseSize(t, o, objectClass(t, o)));
@@ -2383,8 +2136,7 @@ objectHash(Thread* t, object o)
   }
 }
 
-inline bool
-objectEqual(Thread*, object a, object b)
+inline bool objectEqual(Thread*, object a, object b)
 {
   return a == b;
 }
@@ -2469,48 +2221,54 @@ inline bool methodEqual(Thread* t, object ao, object bo)
 
 class MethodSpecIterator {
  public:
-  MethodSpecIterator(Thread* t, const char* s):
-    t(t), s(s + 1)
-  { }
+  MethodSpecIterator(Thread* t, const char* s) : t(t), s(s + 1)
+  {
+  }
 
-  const char* next() {
+  const char* next()
+  {
     assertT(t, *s != ')');
 
     const char* p = s;
 
     switch (*s) {
     case 'L':
-      while (*s and *s != ';') ++ s;
-      ++ s;
+      while (*s and *s != ';')
+        ++s;
+      ++s;
       break;
 
     case '[':
-      while (*s == '[') ++ s;
+      while (*s == '[')
+        ++s;
       switch (*s) {
       case 'L':
-        while (*s and *s != ';') ++ s;
-        ++ s;
+        while (*s and *s != ';')
+          ++s;
+        ++s;
         break;
 
       default:
-        ++ s;
+        ++s;
         break;
       }
       break;
 
     default:
-      ++ s;
+      ++s;
       break;
     }
 
     return p;
   }
 
-  bool hasNext() {
+  bool hasNext()
+  {
     return *s != ')';
   }
 
-  const char* returnSpec() {
+  const char* returnSpec()
+  {
     assertT(t, *s == ')');
     return s + 1;
   }
@@ -2519,17 +2277,13 @@ class MethodSpecIterator {
   const char* s;
 };
 
-unsigned
-fieldCode(Thread* t, unsigned javaCode);
+unsigned fieldCode(Thread* t, unsigned javaCode);
 
-unsigned
-fieldType(Thread* t, unsigned code);
+unsigned fieldType(Thread* t, unsigned code);
 
-unsigned
-primitiveSize(Thread* t, unsigned code);
+unsigned primitiveSize(Thread* t, unsigned code);
 
-inline unsigned
-fieldSize(Thread* t, unsigned code)
+inline unsigned fieldSize(Thread* t, unsigned code)
 {
   if (code == ObjectField) {
     return BytesPerWord;
@@ -2543,16 +2297,18 @@ inline unsigned fieldSize(Thread* t, GcField* field)
   return fieldSize(t, field->code());
 }
 
-inline void
-scanMethodSpec(Thread* t, const char* s, bool static_,
-               unsigned* parameterCount, unsigned* parameterFootprint,
-               unsigned* returnCode)
+inline void scanMethodSpec(Thread* t,
+                           const char* s,
+                           bool static_,
+                           unsigned* parameterCount,
+                           unsigned* parameterFootprint,
+                           unsigned* returnCode)
 {
   unsigned count = 0;
   unsigned footprint = 0;
   MethodSpecIterator it(t, s);
   while (it.hasNext()) {
-    ++ count;
+    ++count;
     switch (*it.next()) {
     case 'J':
     case 'D':
@@ -2560,13 +2316,13 @@ scanMethodSpec(Thread* t, const char* s, bool static_,
       break;
 
     default:
-      ++ footprint;
+      ++footprint;
       break;
     }
   }
 
   if (not static_) {
-    ++ footprint;
+    ++footprint;
   }
 
   *parameterCount = count;
@@ -2583,8 +2339,7 @@ inline bool emptyMethod(Thread* t UNUSED, GcMethod* method)
          and (method->code()->body()[0] == return_);
 }
 
-object
-parseUtf8(Thread* t, const char* data, unsigned length);
+object parseUtf8(Thread* t, const char* data, unsigned length);
 
 object parseUtf8(Thread* t, GcByteArray* array);
 
@@ -2637,8 +2392,8 @@ inline GcMethod* resolveMethod(Thread* t,
                                const char* methodName,
                                const char* methodSpec)
 {
-  return resolveMethod
-    (t, resolveClass(t, loader, className), methodName, methodSpec);
+  return resolveMethod(
+      t, resolveClass(t, loader, className), methodName, methodSpec);
 }
 
 GcField* resolveField(Thread* t,
@@ -2652,8 +2407,8 @@ inline GcField* resolveField(Thread* t,
                              const char* fieldName,
                              const char* fieldSpec)
 {
-  return resolveField
-    (t, resolveClass(t, loader, className), fieldName, fieldSpec);
+  return resolveField(
+      t, resolveClass(t, loader, className), fieldName, fieldSpec);
 }
 
 bool classNeedsInit(Thread* t, GcClass* c);
@@ -2670,8 +2425,7 @@ GcClass* resolveObjectArrayClass(Thread* t,
 
 object makeObjectArray(Thread* t, GcClass* elementClass, unsigned count);
 
-inline object
-makeObjectArray(Thread* t, unsigned count)
+inline object makeObjectArray(Thread* t, unsigned count)
 {
   return makeObjectArray(t, type(t, GcJobject::Type), count);
 }
@@ -2758,21 +2512,17 @@ inline GcThrowable* makeThrowable(Thread* t,
   }
 }
 
-void
-popResources(Thread* t);
+void popResources(Thread* t);
 
-} // namespace vm
+}  // namespace vm
 
-AVIAN_EXPORT void
-vmPrintTrace(vm::Thread* t);
+AVIAN_EXPORT void vmPrintTrace(vm::Thread* t);
 
-AVIAN_EXPORT void
-vmfPrintTrace(vm::Thread* t, FILE* out);
+AVIAN_EXPORT void vmfPrintTrace(vm::Thread* t, FILE* out);
 
 namespace vm {
 
-void
-dumpHeap(Thread* t, FILE* out);
+void dumpHeap(Thread* t, FILE* out);
 
 inline void NO_RETURN throw_(Thread* t, GcThrowable* e)
 {
@@ -2796,7 +2546,7 @@ inline void NO_RETURN throw_(Thread* t, GcThrowable* e)
         }
       }
     }
-#endif//AVIAN_HEAPDUMP
+#endif  // AVIAN_HEAPDUMP
 
     if (AbortOnOutOfMemoryError) {
       fprintf(stderr, "OutOfMemoryError\n");
@@ -2918,16 +2668,14 @@ inline GcMethod* findInterfaceMethod(Thread* t,
   abort(t);
 }
 
-inline unsigned
-objectArrayLength(Thread* t UNUSED, object array)
+inline unsigned objectArrayLength(Thread* t UNUSED, object array)
 {
   assertT(t, objectClass(t, array)->fixedSize() == BytesPerWord * 2);
   assertT(t, objectClass(t, array)->arrayElementSize() == BytesPerWord);
   return fieldAtOffset<uintptr_t>(array, BytesPerWord);
 }
 
-inline object&
-objectArrayBody(Thread* t UNUSED, object array, unsigned index)
+inline object& objectArrayBody(Thread* t UNUSED, object array, unsigned index)
 {
   assertT(t, objectClass(t, array)->fixedSize() == BytesPerWord * 2);
   assertT(t, objectClass(t, array)->arrayElementSize() == BytesPerWord);
@@ -2938,14 +2686,11 @@ objectArrayBody(Thread* t UNUSED, object array, unsigned index)
   return fieldAtOffset<object>(array, ArrayBody + (index * BytesPerWord));
 }
 
-unsigned
-parameterFootprint(Thread* t, const char* s, bool static_);
+unsigned parameterFootprint(Thread* t, const char* s, bool static_);
 
-void
-addFinalizer(Thread* t, object target, void (*finalize)(Thread*, object));
+void addFinalizer(Thread* t, object target, void (*finalize)(Thread*, object));
 
-inline bool
-acquireSystem(Thread* t, Thread* target)
+inline bool acquireSystem(Thread* t, Thread* target)
 {
   ACQUIRE_RAW(t, t->m->stateLock);
 
@@ -2957,8 +2702,7 @@ acquireSystem(Thread* t, Thread* target)
   }
 }
 
-inline void
-releaseSystem(Thread* t, Thread* target)
+inline void releaseSystem(Thread* t, Thread* target)
 {
   ACQUIRE_RAW(t, t->m->stateLock);
 
@@ -2967,14 +2711,15 @@ releaseSystem(Thread* t, Thread* target)
   atomicAnd(&(target->flags), ~Thread::SystemFlag);
 }
 
-inline bool
-atomicCompareAndSwapObject(Thread* t, object target, unsigned offset,
-                           object old, object new_)
+inline bool atomicCompareAndSwapObject(Thread* t,
+                                       object target,
+                                       unsigned offset,
+                                       object old,
+                                       object new_)
 {
   if (atomicCompareAndSwap(&fieldAtOffset<uintptr_t>(target, offset),
                            reinterpret_cast<uintptr_t>(old),
-                           reinterpret_cast<uintptr_t>(new_)))
-  {
+                           reinterpret_cast<uintptr_t>(new_))) {
     mark(t, target, offset);
     return true;
   } else {
@@ -3007,13 +2752,10 @@ inline void monitorAtomicAppendAcquire(Thread* t,
 
     if (tail == cast<GcMonitorNode>(t, monitor->acquireTail())) {
       if (next) {
-        atomicCompareAndSwapObject
-          (t, monitor, MonitorAcquireTail, tail, next);
-      } else if (atomicCompareAndSwapObject
-                 (t, tail, MonitorNodeNext, 0, node))
-      {
-        atomicCompareAndSwapObject
-          (t, monitor, MonitorAcquireTail, tail, node);
+        atomicCompareAndSwapObject(t, monitor, MonitorAcquireTail, tail, next);
+      } else if (atomicCompareAndSwapObject(
+                     t, tail, MonitorNodeNext, 0, node)) {
+        atomicCompareAndSwapObject(t, monitor, MonitorAcquireTail, tail, node);
         return;
       }
     }
@@ -3040,17 +2782,15 @@ inline Thread* monitorAtomicPollAcquire(Thread* t,
     if (head == cast<GcMonitorNode>(t, monitor->acquireHead())) {
       if (head == tail) {
         if (next) {
-          atomicCompareAndSwapObject
-            (t, monitor, MonitorAcquireTail, tail, next);
+          atomicCompareAndSwapObject(
+              t, monitor, MonitorAcquireTail, tail, next);
         } else {
           return 0;
         }
       } else {
         Thread* value = static_cast<Thread*>(next->value());
-        if ((not remove)
-            or atomicCompareAndSwapObject
-            (t, monitor, MonitorAcquireHead, head, next))
-        {
+        if ((not remove) or atomicCompareAndSwapObject(
+                                t, monitor, MonitorAcquireHead, head, next)) {
           return value;
         }
       }
@@ -3205,7 +2945,8 @@ inline bool monitorWait(Thread* t, GcMonitor* monitor, int64_t time)
   GcMonitorNode* monitorNode = makeMonitorNode(t, t, 0);
   PROTECT(t, monitorNode);
 
-  { ACQUIRE(t, t->lock);
+  {
+    ACQUIRE(t, t->lock);
 
     monitorAppendWait(t, monitor);
 
@@ -3275,7 +3016,8 @@ inline void monitorNotifyAll(Thread* t, GcMonitor* monitor)
 {
   PROTECT(t, monitor);
 
-  while (monitorNotify(t, monitor)) { }
+  while (monitorNotify(t, monitor)) {
+  }
 }
 
 class ObjectMonitorResource {
@@ -3286,7 +3028,8 @@ class ObjectMonitorResource {
     monitorAcquire(protector.t, o);
   }
 
-  ~ObjectMonitorResource() {
+  ~ObjectMonitorResource()
+  {
     monitorRelease(protector.t, o);
   }
 
@@ -3297,8 +3040,7 @@ class ObjectMonitorResource {
 
 GcMonitor* objectMonitor(Thread* t, object o, bool createNew);
 
-inline void
-acquire(Thread* t, object o)
+inline void acquire(Thread* t, object o)
 {
   unsigned hash;
   if (DebugMonitors) {
@@ -3314,8 +3056,7 @@ acquire(Thread* t, object o)
   monitorAcquire(t, m);
 }
 
-inline void
-release(Thread* t, object o)
+inline void release(Thread* t, object o)
 {
   unsigned hash;
   if (DebugMonitors) {
@@ -3331,8 +3072,7 @@ release(Thread* t, object o)
   monitorRelease(t, m);
 }
 
-inline void
-wait(Thread* t, object o, int64_t milliseconds)
+inline void wait(Thread* t, object o, int64_t milliseconds)
 {
   unsigned hash;
   if (DebugMonitors) {
@@ -3342,8 +3082,12 @@ wait(Thread* t, object o, int64_t milliseconds)
   GcMonitor* m = objectMonitor(t, o, false);
 
   if (DebugMonitors) {
-    fprintf(stderr, "thread %p waits %d millis on %p for %x\n",
-            t, static_cast<int>(milliseconds), m, hash);
+    fprintf(stderr,
+            "thread %p waits %d millis on %p for %x\n",
+            t,
+            static_cast<int>(milliseconds),
+            m,
+            hash);
   }
 
   if (m and m->owner() == t) {
@@ -3364,15 +3108,13 @@ wait(Thread* t, object o, int64_t milliseconds)
   }
 
   if (DebugMonitors) {
-    fprintf(stderr, "thread %p wakes up on %p for %x\n",
-            t, m, hash);
+    fprintf(stderr, "thread %p wakes up on %p for %x\n", t, m, hash);
   }
 
   stress(t);
 }
 
-inline void
-notify(Thread* t, object o)
+inline void notify(Thread* t, object o)
 {
   unsigned hash;
   if (DebugMonitors) {
@@ -3382,8 +3124,7 @@ notify(Thread* t, object o)
   GcMonitor* m = objectMonitor(t, o, false);
 
   if (DebugMonitors) {
-    fprintf(stderr, "thread %p notifies on %p for %x\n",
-            t, m, hash);
+    fprintf(stderr, "thread %p notifies on %p for %x\n", t, m, hash);
   }
 
   if (m and m->owner() == t) {
@@ -3393,14 +3134,16 @@ notify(Thread* t, object o)
   }
 }
 
-inline void
-notifyAll(Thread* t, object o)
+inline void notifyAll(Thread* t, object o)
 {
   GcMonitor* m = objectMonitor(t, o, false);
 
   if (DebugMonitors) {
-    fprintf(stderr, "thread %p notifies all on %p for %x\n",
-            t, m, objectHash(t, o));
+    fprintf(stderr,
+            "thread %p notifies all on %p for %x\n",
+            t,
+            m,
+            objectHash(t, o));
   }
 
   if (m and m->owner() == t) {
@@ -3410,8 +3153,7 @@ notifyAll(Thread* t, object o)
   }
 }
 
-inline void
-interrupt(Thread* t, Thread* target)
+inline void interrupt(Thread* t, Thread* target)
 {
   if (acquireSystem(t, target)) {
     target->systemThread->interrupt();
@@ -3419,8 +3161,7 @@ interrupt(Thread* t, Thread* target)
   }
 }
 
-inline bool
-getAndClearInterrupted(Thread* t, Thread* target)
+inline bool getAndClearInterrupted(Thread* t, Thread* target)
 {
   if (acquireSystem(t, target)) {
     bool result = target->systemThread->getAndClearInterrupted();
@@ -3437,26 +3178,20 @@ inline bool exceptionMatch(Thread* t, GcClass* type, GcThrowable* exception)
                        and instanceOf(t, type, t->exception));
 }
 
-object
-intern(Thread* t, object s);
+object intern(Thread* t, object s);
 
-void
-walk(Thread* t, Heap::Walker* w, object o, unsigned start);
+void walk(Thread* t, Heap::Walker* w, object o, unsigned start);
 
-int
-walkNext(Thread* t, object o, int previous);
+int walkNext(Thread* t, object o, int previous);
 
-void
-visitRoots(Machine* m, Heap::Visitor* v);
+void visitRoots(Machine* m, Heap::Visitor* v);
 
-inline jobject
-makeLocalReference(Thread* t, object o)
+inline jobject makeLocalReference(Thread* t, object o)
 {
   return t->m->processor->makeLocalReference(t, o);
 }
 
-inline void
-disposeLocalReference(Thread* t, jobject r)
+inline void disposeLocalReference(Thread* t, jobject r)
 {
   t->m->processor->disposeLocalReference(t, r);
 }
@@ -3467,8 +3202,7 @@ inline bool methodVirtual(Thread* t UNUSED, GcMethod* method)
          and method->name()->body()[0] != '<';
 }
 
-inline unsigned
-singletonMaskSize(unsigned count, unsigned bitsPerWord)
+inline unsigned singletonMaskSize(unsigned count, unsigned bitsPerWord)
 {
   if (count) {
     return ceilingDivide(count + 2, bitsPerWord);
@@ -3476,8 +3210,7 @@ singletonMaskSize(unsigned count, unsigned bitsPerWord)
   return 0;
 }
 
-inline unsigned
-singletonMaskSize(unsigned count)
+inline unsigned singletonMaskSize(unsigned count)
 {
   return singletonMaskSize(count, BitsPerWord);
 }
@@ -3503,11 +3236,9 @@ inline uint32_t* singletonMask(Thread* t UNUSED, GcSingleton* singleton)
       &singleton->body()[singletonCount(t, singleton)]);
 }
 
-inline void
-singletonMarkObject(uint32_t* mask, unsigned index)
+inline void singletonMarkObject(uint32_t* mask, unsigned index)
 {
-  mask[(index + 2) / 32]
-    |= (static_cast<uint32_t>(1) << ((index + 2) % 32));
+  mask[(index + 2) / 32] |= (static_cast<uint32_t>(1) << ((index + 2) % 32));
 }
 
 inline void singletonMarkObject(Thread* t,
@@ -3557,7 +3288,7 @@ inline void singletonSetBit(Thread* t,
                             unsigned index)
 {
   singletonValue(t, singleton, start + (index / BitsPerWord))
-    |= static_cast<uintptr_t>(1) << (index % BitsPerWord);
+      |= static_cast<uintptr_t>(1) << (index % BitsPerWord);
 }
 
 inline bool singletonBit(Thread* t,
@@ -3569,14 +3300,12 @@ inline bool singletonBit(Thread* t,
           & (static_cast<uintptr_t>(1) << (index % BitsPerWord))) != 0;
 }
 
-inline unsigned
-poolMaskSize(unsigned count, unsigned bitsPerWord)
+inline unsigned poolMaskSize(unsigned count, unsigned bitsPerWord)
 {
   return ceilingDivide(count, bitsPerWord);
 }
 
-inline unsigned
-poolMaskSize(unsigned count)
+inline unsigned poolMaskSize(unsigned count)
 {
   return poolMaskSize(count, BitsPerWord);
 }
@@ -3751,7 +3480,8 @@ class FieldReadResource {
     acquireFieldForRead(protector.t, o);
   }
 
-  ~FieldReadResource() {
+  ~FieldReadResource()
+  {
     releaseFieldForRead(protector.t, o);
   }
 
@@ -3791,7 +3521,8 @@ class FieldWriteResource {
     acquireFieldForWrite(protector.t, o);
   }
 
-  ~FieldWriteResource() {
+  ~FieldWriteResource()
+  {
     releaseFieldForWrite(protector.t, o);
   }
 
@@ -3975,9 +3706,11 @@ inline void unregisterNatives(Thread* t, GcClass* c)
   }
 }
 
-void
-populateMultiArray(Thread* t, object array, int32_t* counts,
-                   unsigned index, unsigned dimensions);
+void populateMultiArray(Thread* t,
+                        object array,
+                        int32_t* counts,
+                        unsigned index,
+                        unsigned dimensions);
 
 GcMethod* getCaller(Thread* t, unsigned target, bool skipMethodInvoke = false);
 
@@ -4004,65 +3737,58 @@ inline GcMethod* methodClone(Thread* t, GcMethod* method)
                     method->code());
 }
 
-inline uint64_t
-exceptionHandler(uint64_t start, uint64_t end, uint64_t ip, uint64_t catchType)
+inline uint64_t exceptionHandler(uint64_t start,
+                                 uint64_t end,
+                                 uint64_t ip,
+                                 uint64_t catchType)
 {
   return (start << 48) | (end << 32) | (ip << 16) | catchType;
 }
 
-inline unsigned
-exceptionHandlerStart(uint64_t eh)
+inline unsigned exceptionHandlerStart(uint64_t eh)
 {
   return eh >> 48;
 }
 
-inline unsigned
-exceptionHandlerEnd(uint64_t eh)
+inline unsigned exceptionHandlerEnd(uint64_t eh)
 {
   return (eh >> 32) & 0xFFFF;
 }
 
-inline unsigned
-exceptionHandlerIp(uint64_t eh)
+inline unsigned exceptionHandlerIp(uint64_t eh)
 {
   return (eh >> 16) & 0xFFFF;
 }
 
-inline unsigned
-exceptionHandlerCatchType(uint64_t eh)
+inline unsigned exceptionHandlerCatchType(uint64_t eh)
 {
   return eh & 0xFFFF;
 }
 
-inline uint64_t
-lineNumber(uint64_t ip, uint64_t line)
+inline uint64_t lineNumber(uint64_t ip, uint64_t line)
 {
   return (ip << 32) | line;
 }
 
-inline unsigned
-lineNumberIp(uint64_t ln)
+inline unsigned lineNumberIp(uint64_t ln)
 {
   return ln >> 32;
 }
 
-inline unsigned
-lineNumberLine(uint64_t ln)
+inline unsigned lineNumberLine(uint64_t ln)
 {
   return ln & 0xFFFFFFFF;
 }
 
 object interruptLock(Thread* t, GcThread* thread);
 
-void
-clearInterrupted(Thread* t);
+void clearInterrupted(Thread* t);
 
 void threadInterrupt(Thread* t, GcThread* thread);
 
 bool threadIsInterrupted(Thread* t, GcThread* thread, bool clear);
 
-inline FILE*
-errorLog(Thread* t)
+inline FILE* errorLog(Thread* t)
 {
   if (t->m->errorLog == 0) {
     const char* path = findProperty(t, "avian.error.log");
@@ -4076,9 +3802,10 @@ errorLog(Thread* t)
   return t->m->errorLog;
 }
 
-} // namespace vm
+}  // namespace vm
 
-AVIAN_EXPORT void*
-vmAddressFromLine(vm::Thread* t, vm::object m, unsigned line);
+AVIAN_EXPORT void* vmAddressFromLine(vm::Thread* t,
+                                     vm::object m,
+                                     unsigned line);
 
-#endif//MACHINE_H
+#endif  // MACHINE_H
diff --git a/src/avian/process.h b/src/avian/process.h
index e68be059d0..d1e94a1c7c 100644
--- a/src/avian/process.h
+++ b/src/avian/process.h
@@ -56,6 +56,6 @@ void resolveNative(Thread* t, GcMethod* method);
 
 int findLineNumber(Thread* t, GcMethod* method, unsigned ip);
 
-} // namespace vm
+}  // namespace vm
 
-#endif//PROCESS_H
+#endif  // PROCESS_H
diff --git a/src/avian/processor.h b/src/avian/processor.h
index 172b8f5977..1a9f3ec43a 100644
--- a/src/avian/processor.h
+++ b/src/avian/processor.h
@@ -69,7 +69,10 @@ class Processor {
 
   class CompilationHandler {
    public:
-    virtual void compiled(const void* code, unsigned size, unsigned frameSize, const char* name) = 0;
+    virtual void compiled(const void* code,
+                          unsigned size,
+                          unsigned frameSize,
+                          const char* name) = 0;
 
     virtual void dispose() = 0;
   };
@@ -112,25 +115,19 @@ class Processor {
 
   virtual void initVtable(Thread* t, GcClass* c) = 0;
 
-  virtual void
-  visitObjects(Thread* t, Heap::Visitor* v) = 0;
+  virtual void visitObjects(Thread* t, Heap::Visitor* v) = 0;
 
-  virtual void
-  walkStack(Thread* t, StackVisitor* v) = 0;
+  virtual void walkStack(Thread* t, StackVisitor* v) = 0;
 
   virtual int lineNumber(Thread* t, GcMethod* method, int ip) = 0;
 
-  virtual object*
-  makeLocalReference(Thread* t, object o) = 0;
+  virtual object* makeLocalReference(Thread* t, object o) = 0;
 
-  virtual void
-  disposeLocalReference(Thread* t, object* r) = 0;
+  virtual void disposeLocalReference(Thread* t, object* r) = 0;
 
-  virtual bool
-  pushLocalFrame(Thread* t, unsigned capacity) = 0;
+  virtual bool pushLocalFrame(Thread* t, unsigned capacity) = 0;
 
-  virtual void
-  popLocalFrame(Thread* t) = 0;
+  virtual void popLocalFrame(Thread* t) = 0;
 
   virtual object invokeArray(Thread* t,
                              GcMethod* method,
@@ -156,20 +153,16 @@ class Processor {
                             object this_,
                             va_list arguments) = 0;
 
-  virtual void
-  dispose(Thread* t) = 0;
+  virtual void dispose(Thread* t) = 0;
 
-  virtual void
-  dispose() = 0;
+  virtual void dispose() = 0;
 
-  virtual object
-  getStackTrace(Thread* t, Thread* target) = 0;
+  virtual object getStackTrace(Thread* t, Thread* target) = 0;
 
   virtual void initialize(BootImage* image, avian::util::Slice<uint8_t> code)
       = 0;
 
-  virtual void
-  addCompilationHandler(CompilationHandler* handler) = 0;
+  virtual void addCompilationHandler(CompilationHandler* handler) = 0;
 
   virtual void compileMethod(Thread* t,
                              Zone* zone,
@@ -179,23 +172,18 @@ class Processor {
                              GcMethod* method,
                              OffsetResolver* resolver) = 0;
 
-  virtual void
-  visitRoots(Thread* t, HeapWalker* w) = 0;
+  virtual void visitRoots(Thread* t, HeapWalker* w) = 0;
 
-  virtual void
-  normalizeVirtualThunks(Thread* t) = 0;
+  virtual void normalizeVirtualThunks(Thread* t) = 0;
 
-  virtual unsigned*
-  makeCallTable(Thread* t, HeapWalker* w) = 0;
+  virtual unsigned* makeCallTable(Thread* t, HeapWalker* w) = 0;
 
-  virtual void
-  boot(Thread* t, BootImage* image, uint8_t* code) = 0;
+  virtual void boot(Thread* t, BootImage* image, uint8_t* code) = 0;
 
-  virtual void
-  callWithCurrentContinuation(Thread* t, object receiver) = 0;
+  virtual void callWithCurrentContinuation(Thread* t, object receiver) = 0;
 
-  virtual void
-  dynamicWind(Thread* t, object before, object thunk, object after) = 0;
+  virtual void dynamicWind(Thread* t, object before, object thunk, object after)
+      = 0;
 
   virtual void feedResultToContinuation(Thread* t,
                                         GcContinuation* continuation,
@@ -205,9 +193,10 @@ class Processor {
                                            GcContinuation* continuation,
                                            GcThrowable* exception) = 0;
 
-  virtual void
-  walkContinuationBody(Thread* t, Heap::Walker* w, object o, unsigned start)
-  = 0;
+  virtual void walkContinuationBody(Thread* t,
+                                    Heap::Walker* w,
+                                    object o,
+                                    unsigned start) = 0;
 
   object invoke(Thread* t, GcMethod* method, object this_, ...)
   {
@@ -232,8 +221,8 @@ class Processor {
     va_list a;
     va_start(a, this_);
 
-    object r = invokeList
-      (t, loader, className, methodName, methodSpec, this_, a);
+    object r
+        = invokeList(t, loader, className, methodName, methodSpec, this_, a);
 
     va_end(a);
 
@@ -246,6 +235,6 @@ Processor* makeProcessor(System* system,
                          const char* crashDumpDirectory,
                          bool useNativeFeatures);
 
-} // namespace vm
+}  // namespace vm
 
-#endif//PROCESSOR_H
+#endif  // PROCESSOR_H
diff --git a/src/avian/target-fields.h b/src/avian/target-fields.h
index 9efc1212e8..70c6dd22b6 100644
--- a/src/avian/target-fields.h
+++ b/src/avian/target-fields.h
@@ -11,9 +11,8 @@
 #ifndef AVIAN_TARGET_FIELDS_H
 #define AVIAN_TARGET_FIELDS_H
 
-
 #ifdef TARGET_BYTES_PER_WORD
-#  if (TARGET_BYTES_PER_WORD == 8)
+#if (TARGET_BYTES_PER_WORD == 8)
 
 #define TARGET_THREAD_EXCEPTION 80
 #define TARGET_THREAD_EXCEPTIONSTACKADJUSTMENT 2264
@@ -33,7 +32,7 @@
 #define TARGET_THREAD_THUNKTABLE 2328
 #define TARGET_THREAD_STACKLIMIT 2376
 
-#  elif (TARGET_BYTES_PER_WORD == 4)
+#elif(TARGET_BYTES_PER_WORD == 4)
 
 #define TARGET_THREAD_EXCEPTION 44
 #define TARGET_THREAD_EXCEPTIONSTACKADJUSTMENT 2168
@@ -53,12 +52,11 @@
 #define TARGET_THREAD_THUNKTABLE 2200
 #define TARGET_THREAD_STACKLIMIT 2224
 
-#  else
-#    error
-#  endif
 #else
-#  error
+#error
+#endif
+#else
+#error
 #endif
 
 #endif
-
diff --git a/src/avian/target.h b/src/avian/target.h
index c796855ddc..dd354b66eb 100644
--- a/src/avian/target.h
+++ b/src/avian/target.h
@@ -17,96 +17,82 @@
 namespace vm {
 
 template <class T>
-inline T
-targetV1(T v)
+inline T targetV1(T v)
 {
   return v;
 }
 
 template <class T>
-inline T
-swapV2(T v)
+inline T swapV2(T v)
 {
-  return (((v >> 8) & 0xFF) |
-          ((v << 8)));
+  return (((v >> 8) & 0xFF) | ((v << 8)));
 }
 
 template <class T>
-inline T
-swapV4(T v)
+inline T swapV4(T v)
 {
-  return (((v >> 24) & 0x000000FF) |
-          ((v >>  8) & 0x0000FF00) |
-          ((v <<  8) & 0x00FF0000) |
-          ((v << 24)));
+  return (((v >> 24) & 0x000000FF) | ((v >> 8) & 0x0000FF00)
+          | ((v << 8) & 0x00FF0000) | ((v << 24)));
 }
 
 template <class T>
-inline T
-swapV8(T v)
+inline T swapV8(T v)
 {
-  return (((static_cast<uint64_t>(v) >> 56) & UINT64_C(0x00000000000000FF)) |
-          ((static_cast<uint64_t>(v) >> 40) & UINT64_C(0x000000000000FF00)) |
-          ((static_cast<uint64_t>(v) >> 24) & UINT64_C(0x0000000000FF0000)) |
-          ((static_cast<uint64_t>(v) >>  8) & UINT64_C(0x00000000FF000000)) |
-          ((static_cast<uint64_t>(v) <<  8) & UINT64_C(0x000000FF00000000)) |
-          ((static_cast<uint64_t>(v) << 24) & UINT64_C(0x0000FF0000000000)) |
-          ((static_cast<uint64_t>(v) << 40) & UINT64_C(0x00FF000000000000)) |
-          ((static_cast<uint64_t>(v) << 56)));
+  return (((static_cast<uint64_t>(v) >> 56) & UINT64_C(0x00000000000000FF))
+          | ((static_cast<uint64_t>(v) >> 40) & UINT64_C(0x000000000000FF00))
+          | ((static_cast<uint64_t>(v) >> 24) & UINT64_C(0x0000000000FF0000))
+          | ((static_cast<uint64_t>(v) >> 8) & UINT64_C(0x00000000FF000000))
+          | ((static_cast<uint64_t>(v) << 8) & UINT64_C(0x000000FF00000000))
+          | ((static_cast<uint64_t>(v) << 24) & UINT64_C(0x0000FF0000000000))
+          | ((static_cast<uint64_t>(v) << 40) & UINT64_C(0x00FF000000000000))
+          | ((static_cast<uint64_t>(v) << 56)));
 }
 
 #ifdef TARGET_OPPOSITE_ENDIAN
 
 template <class T>
-inline T
-targetV2(T v)
+inline T targetV2(T v)
 {
   return swapV2(v);
 }
 
 template <class T>
-inline T
-targetV4(T v)
+inline T targetV4(T v)
 {
   return swapV4(v);
 }
 
 template <class T>
-inline T
-targetV8(T v)
+inline T targetV8(T v)
 {
   return swapV8(v);
 }
 
 #else
 template <class T>
-inline T
-targetV2(T v)
+inline T targetV2(T v)
 {
   return v;
 }
 
 template <class T>
-inline T
-targetV4(T v)
+inline T targetV4(T v)
 {
   return v;
 }
 
 template <class T>
-inline T
-targetV8(T v)
+inline T targetV8(T v)
 {
   return v;
 }
 #endif
 
 #ifdef TARGET_BYTES_PER_WORD
-#  if (TARGET_BYTES_PER_WORD == 8)
+#if (TARGET_BYTES_PER_WORD == 8)
 
 template <class T>
-inline T
-targetVW(T v)
+inline T targetVW(T v)
 {
   return targetV8(v);
 }
@@ -120,11 +106,10 @@ const unsigned TargetClassVtable = 136;
 
 const unsigned TargetFieldOffset = 12;
 
-#  elif (TARGET_BYTES_PER_WORD == 4)
+#elif(TARGET_BYTES_PER_WORD == 4)
 
 template <class T>
-inline T
-targetVW(T v)
+inline T targetVW(T v)
 {
   return targetV4(v);
 }
@@ -138,11 +123,11 @@ const unsigned TargetClassVtable = 72;
 
 const unsigned TargetFieldOffset = 8;
 
-#  else
-#    error
-#  endif
 #else
-#  error
+#error
+#endif
+#else
+#error
 #endif
 
 const unsigned TargetBytesPerWord = TARGET_BYTES_PER_WORD;
@@ -150,19 +135,18 @@ const unsigned TargetBytesPerWord = TARGET_BYTES_PER_WORD;
 const unsigned TargetBitsPerWord = TargetBytesPerWord * 8;
 
 const target_uintptr_t TargetPointerMask
-= ((~static_cast<target_uintptr_t>(0)) / TargetBytesPerWord)
-  * TargetBytesPerWord;
+    = ((~static_cast<target_uintptr_t>(0)) / TargetBytesPerWord)
+      * TargetBytesPerWord;
 
 const unsigned TargetArrayLength = TargetBytesPerWord;
 const unsigned TargetArrayBody = TargetBytesPerWord * 2;
 
-inline void
-targetMarkBit(target_uintptr_t* map, unsigned i)
+inline void targetMarkBit(target_uintptr_t* map, unsigned i)
 {
-  map[wordOf<target_uintptr_t>(i)] |=
-    targetVW(static_cast<target_uintptr_t>(1) << bitOf<target_uintptr_t>(i));
+  map[wordOf<target_uintptr_t>(i)] |= targetVW(static_cast<target_uintptr_t>(1)
+                                               << bitOf<target_uintptr_t>(i));
 }
 
-} // namespace vm
+}  // namespace vm
 
-#endif//TARGET_H
+#endif  // TARGET_H
diff --git a/src/avian/types.h b/src/avian/types.h
index d2ff41669d..6e0e396641 100644
--- a/src/avian/types.h
+++ b/src/avian/types.h
@@ -20,4 +20,4 @@
 #define DOUBLE_TYPE 6
 #define POINTER_TYPE 7
 
-#endif//TYPES_H
+#endif  // TYPES_H
diff --git a/src/avian/util.h b/src/avian/util.h
index e98691f00a..852d480499 100644
--- a/src/avian/util.h
+++ b/src/avian/util.h
@@ -84,15 +84,13 @@ object hashMapRemove(Thread* t,
 
 object hashMapIterator(Thread* t, GcHashMap* map);
 
-object
-hashMapIteratorNext(Thread* t, object it);
+object hashMapIteratorNext(Thread* t, object it);
 
 void listAppend(Thread* t, GcList* list, object value);
 
 GcVector* vectorAppend(Thread* t, GcVector* vector, object value);
 
-object
-growArray(Thread* t, object array);
+object growArray(Thread* t, object array);
 
 object treeQuery(Thread* t,
                  GcTreeNode* tree,
@@ -115,7 +113,7 @@ void treeUpdate(Thread* t,
                 GcTreeNode* sentinal,
                 intptr_t (*compare)(Thread* t, intptr_t key, object b));
 
-class HashMapIterator: public Thread::Protector {
+class HashMapIterator : public Thread::Protector {
  public:
   HashMapIterator(Thread* t, GcHashMap* map)
       : Protector(t), map(map), node(0), index(0)
@@ -123,7 +121,8 @@ class HashMapIterator: public Thread::Protector {
     find();
   }
 
-  void find() {
+  void find()
+  {
     GcArray* array = map->array();
     if (array) {
       for (unsigned i = index; i < array->length(); ++i) {
@@ -137,7 +136,8 @@ class HashMapIterator: public Thread::Protector {
     node = 0;
   }
 
-  bool hasMore() {
+  bool hasMore()
+  {
     return node != 0;
   }
 
@@ -156,7 +156,8 @@ class HashMapIterator: public Thread::Protector {
     }
   }
 
-  virtual void visit(Heap::Visitor* v) {
+  virtual void visit(Heap::Visitor* v)
+  {
     v->visit(&map);
     v->visit(&node);
   }
@@ -166,6 +167,6 @@ class HashMapIterator: public Thread::Protector {
   unsigned index;
 };
 
-} // vm
+}  // vm
 
-#endif//UTIL_H
+#endif  // UTIL_H
diff --git a/src/avian/x86.h b/src/avian/x86.h
index 25ff5b560f..c4cd4e58b4 100644
--- a/src/avian/x86.h
+++ b/src/avian/x86.h
@@ -15,150 +15,164 @@
 #include "avian/common.h"
 
 #ifdef _MSC_VER
-#  include "windows.h"
-#  pragma push_macro("assert")
-#  include "intrin.h"
-#  pragma pop_macro("assert")
-#  undef interface
+#include "windows.h"
+#pragma push_macro("assert")
+#include "intrin.h"
+#pragma pop_macro("assert")
+#undef interface
 #endif
 
 #if (defined ARCH_x86_32) || (defined PLATFORM_WINDOWS)
-#  define VA_LIST(x) (&(x))
+#define VA_LIST(x) (&(x))
 #else
-#  define VA_LIST(x) (x)
+#define VA_LIST(x) (x)
 #endif
 
 #ifdef __APPLE__
-#  include "mach/mach_types.h"
-#  include "mach/thread_act.h"
-#  include "mach/thread_status.h"
+#include "mach/mach_types.h"
+#include "mach/thread_act.h"
+#include "mach/thread_status.h"
 
-#  if __DARWIN_UNIX03 && defined(_STRUCT_X86_EXCEPTION_STATE32)
-#    define FIELD(x) __##x
-#  else
-#    define FIELD(x) x
-#  endif
+#if __DARWIN_UNIX03 && defined(_STRUCT_X86_EXCEPTION_STATE32)
+#define FIELD(x) __##x
+#else
+#define FIELD(x) x
+#endif
 #endif
 
 #ifdef ARCH_x86_32
 
-#  ifdef __APPLE__
-#    define THREAD_STATE x86_THREAD_STATE32
-#    define THREAD_STATE_TYPE x86_thread_state32_t
-#    define THREAD_STATE_COUNT x86_THREAD_STATE32_COUNT
+#ifdef __APPLE__
+#define THREAD_STATE x86_THREAD_STATE32
+#define THREAD_STATE_TYPE x86_thread_state32_t
+#define THREAD_STATE_COUNT x86_THREAD_STATE32_COUNT
 
-#    define THREAD_STATE_IP(state) ((state).FIELD(eip))
-#    define THREAD_STATE_STACK(state) ((state).FIELD(esp))
-#    define THREAD_STATE_THREAD(state) ((state).FIELD(ebx))
-#    define THREAD_STATE_LINK(state) ((state).FIELD(ecx))
-#    define THREAD_STATE_FRAME(state) ((state).FIELD(ebp))
+#define THREAD_STATE_IP(state) ((state).FIELD(eip))
+#define THREAD_STATE_STACK(state) ((state).FIELD(esp))
+#define THREAD_STATE_THREAD(state) ((state).FIELD(ebx))
+#define THREAD_STATE_LINK(state) ((state).FIELD(ecx))
+#define THREAD_STATE_FRAME(state) ((state).FIELD(ebp))
 
-#    define IP_REGISTER(context) \
-  THREAD_STATE_IP(context->uc_mcontext->FIELD(ss))
-#    define STACK_REGISTER(context) \
+#define IP_REGISTER(context) THREAD_STATE_IP(context->uc_mcontext->FIELD(ss))
+#define STACK_REGISTER(context) \
   THREAD_STATE_STACK(context->uc_mcontext->FIELD(ss))
-#    define THREAD_REGISTER(context) \
+#define THREAD_REGISTER(context) \
   THREAD_STATE_THREAD(context->uc_mcontext->FIELD(ss))
-#    define LINK_REGISTER(context) \
+#define LINK_REGISTER(context) \
   THREAD_STATE_LINK(context->uc_mcontext->FIELD(ss))
-#    define FRAME_REGISTER(context) \
+#define FRAME_REGISTER(context) \
   THREAD_STATE_FRAME(context->uc_mcontext->FIELD(ss))
 
-#  elif (defined __QNX__)
-#    define IP_REGISTER(context) (context->uc_mcontext.cpu.eip)
-#    define STACK_REGISTER(context) (context->uc_mcontext.cpu.esp)
-#    define THREAD_REGISTER(context) (context->uc_mcontext.cpu.ebx)
-#    define LINK_REGISTER(context) (context->uc_mcontext.cpu.ecx)
-#    define FRAME_REGISTER(context) (context->uc_mcontext.cpu.ebp)
-#  elif (defined __FreeBSD__)
-#    define IP_REGISTER(context) (context->uc_mcontext.mc_eip)
-#    define STACK_REGISTER(context) (context->uc_mcontext.mc_esp)
-#    define THREAD_REGISTER(context) (context->uc_mcontext.mc_ebx)
-#    define LINK_REGISTER(context) (context->uc_mcontext.mc_ecx)
-#    define FRAME_REGISTER(context) (context->uc_mcontext.mc_ebp)
-#  else
-#    define IP_REGISTER(context) (context->uc_mcontext.gregs[REG_EIP])
-#    define STACK_REGISTER(context) (context->uc_mcontext.gregs[REG_ESP])
-#    define THREAD_REGISTER(context) (context->uc_mcontext.gregs[REG_EBX])
-#    define LINK_REGISTER(context) (context->uc_mcontext.gregs[REG_ECX])
-#    define FRAME_REGISTER(context) (context->uc_mcontext.gregs[REG_EBP])
-#  endif
+#elif(defined __QNX__)
+#define IP_REGISTER(context) (context->uc_mcontext.cpu.eip)
+#define STACK_REGISTER(context) (context->uc_mcontext.cpu.esp)
+#define THREAD_REGISTER(context) (context->uc_mcontext.cpu.ebx)
+#define LINK_REGISTER(context) (context->uc_mcontext.cpu.ecx)
+#define FRAME_REGISTER(context) (context->uc_mcontext.cpu.ebp)
+#elif(defined __FreeBSD__)
+#define IP_REGISTER(context) (context->uc_mcontext.mc_eip)
+#define STACK_REGISTER(context) (context->uc_mcontext.mc_esp)
+#define THREAD_REGISTER(context) (context->uc_mcontext.mc_ebx)
+#define LINK_REGISTER(context) (context->uc_mcontext.mc_ecx)
+#define FRAME_REGISTER(context) (context->uc_mcontext.mc_ebp)
+#else
+#define IP_REGISTER(context) (context->uc_mcontext.gregs[REG_EIP])
+#define STACK_REGISTER(context) (context->uc_mcontext.gregs[REG_ESP])
+#define THREAD_REGISTER(context) (context->uc_mcontext.gregs[REG_EBX])
+#define LINK_REGISTER(context) (context->uc_mcontext.gregs[REG_ECX])
+#define FRAME_REGISTER(context) (context->uc_mcontext.gregs[REG_EBP])
+#endif
 
-extern "C" uint64_t
-vmNativeCall(void* function, void* stack, unsigned stackSize,
-             unsigned returnType);
+extern "C" uint64_t vmNativeCall(void* function,
+                                 void* stack,
+                                 unsigned stackSize,
+                                 unsigned returnType);
 
 namespace vm {
 
-inline uint64_t
-dynamicCall(void* function, uintptr_t* arguments, uint8_t*,
-            unsigned, unsigned argumentsSize, unsigned returnType)
+inline uint64_t dynamicCall(void* function,
+                            uintptr_t* arguments,
+                            uint8_t*,
+                            unsigned,
+                            unsigned argumentsSize,
+                            unsigned returnType)
 {
   return vmNativeCall(function, arguments, argumentsSize, returnType);
 }
 
-} // namespace vm
+}  // namespace vm
 
 #elif defined ARCH_x86_64
 
-#  ifdef __APPLE__
-#    define THREAD_STATE x86_THREAD_STATE64
-#    define THREAD_STATE_TYPE x86_thread_state64_t
-#    define THREAD_STATE_COUNT x86_THREAD_STATE64_COUNT
+#ifdef __APPLE__
+#define THREAD_STATE x86_THREAD_STATE64
+#define THREAD_STATE_TYPE x86_thread_state64_t
+#define THREAD_STATE_COUNT x86_THREAD_STATE64_COUNT
 
-#    define THREAD_STATE_IP(state) ((state).FIELD(rip))
-#    define THREAD_STATE_STACK(state) ((state).FIELD(rsp))
-#    define THREAD_STATE_THREAD(state) ((state).FIELD(rbx))
-#    define THREAD_STATE_LINK(state) ((state).FIELD(rcx))
-#    define THREAD_STATE_FRAME(state) ((state).FIELD(rbp))
+#define THREAD_STATE_IP(state) ((state).FIELD(rip))
+#define THREAD_STATE_STACK(state) ((state).FIELD(rsp))
+#define THREAD_STATE_THREAD(state) ((state).FIELD(rbx))
+#define THREAD_STATE_LINK(state) ((state).FIELD(rcx))
+#define THREAD_STATE_FRAME(state) ((state).FIELD(rbp))
 
-#    define IP_REGISTER(context) \
-  THREAD_STATE_IP(context->uc_mcontext->FIELD(ss))
-#    define STACK_REGISTER(context) \
+#define IP_REGISTER(context) THREAD_STATE_IP(context->uc_mcontext->FIELD(ss))
+#define STACK_REGISTER(context) \
   THREAD_STATE_STACK(context->uc_mcontext->FIELD(ss))
-#    define THREAD_REGISTER(context) \
+#define THREAD_REGISTER(context) \
   THREAD_STATE_THREAD(context->uc_mcontext->FIELD(ss))
-#    define LINK_REGISTER(context) \
+#define LINK_REGISTER(context) \
   THREAD_STATE_LINK(context->uc_mcontext->FIELD(ss))
-#    define FRAME_REGISTER(context) \
+#define FRAME_REGISTER(context) \
   THREAD_STATE_FRAME(context->uc_mcontext->FIELD(ss))
 
-#  elif (defined __FreeBSD__)
-#    define IP_REGISTER(context) (context->uc_mcontext.mc_rip)
-#    define STACK_REGISTER(context) (context->uc_mcontext.mc_rsp)
-#    define THREAD_REGISTER(context) (context->uc_mcontext.mc_rbx)
-#    define LINK_REGISTER(context) (context->uc_mcontext.mc_rcx)
-#    define FRAME_REGISTER(context) (context->uc_mcontext.mc_rbp)
-#  else
-#    define IP_REGISTER(context) (context->uc_mcontext.gregs[REG_RIP])
-#    define STACK_REGISTER(context) (context->uc_mcontext.gregs[REG_RSP])
-#    define THREAD_REGISTER(context) (context->uc_mcontext.gregs[REG_RBX])
-#    define LINK_REGISTER(context) (context->uc_mcontext.gregs[REG_RCX])
-#    define FRAME_REGISTER(context) (context->uc_mcontext.gregs[REG_RBP])
-#  endif
+#elif(defined __FreeBSD__)
+#define IP_REGISTER(context) (context->uc_mcontext.mc_rip)
+#define STACK_REGISTER(context) (context->uc_mcontext.mc_rsp)
+#define THREAD_REGISTER(context) (context->uc_mcontext.mc_rbx)
+#define LINK_REGISTER(context) (context->uc_mcontext.mc_rcx)
+#define FRAME_REGISTER(context) (context->uc_mcontext.mc_rbp)
+#else
+#define IP_REGISTER(context) (context->uc_mcontext.gregs[REG_RIP])
+#define STACK_REGISTER(context) (context->uc_mcontext.gregs[REG_RSP])
+#define THREAD_REGISTER(context) (context->uc_mcontext.gregs[REG_RBX])
+#define LINK_REGISTER(context) (context->uc_mcontext.gregs[REG_RCX])
+#define FRAME_REGISTER(context) (context->uc_mcontext.gregs[REG_RBP])
+#endif
 
 extern "C" uint64_t
-#  ifdef PLATFORM_WINDOWS
-vmNativeCall(void* function, void* stack, unsigned stackSize,
-             unsigned returnType);
-#  else
-vmNativeCall(void* function, void* stack, unsigned stackSize,
-             void* gprTable, void* sseTable, unsigned returnType);
-#  endif
+#ifdef PLATFORM_WINDOWS
+    vmNativeCall(void* function,
+                 void* stack,
+                 unsigned stackSize,
+                 unsigned returnType);
+#else
+    vmNativeCall(void* function,
+                 void* stack,
+                 unsigned stackSize,
+                 void* gprTable,
+                 void* sseTable,
+                 unsigned returnType);
+#endif
 
 namespace vm {
 
-#  ifdef PLATFORM_WINDOWS
-inline uint64_t
-dynamicCall(void* function, uint64_t* arguments, UNUSED uint8_t* argumentTypes,
-            unsigned argumentCount, unsigned, unsigned returnType)
+#ifdef PLATFORM_WINDOWS
+inline uint64_t dynamicCall(void* function,
+                            uint64_t* arguments,
+                            UNUSED uint8_t* argumentTypes,
+                            unsigned argumentCount,
+                            unsigned,
+                            unsigned returnType)
 {
   return vmNativeCall(function, arguments, argumentCount, returnType);
 }
-#  else
-inline uint64_t
-dynamicCall(void* function, uintptr_t* arguments, uint8_t* argumentTypes,
-            unsigned argumentCount, unsigned, unsigned returnType)
+#else
+inline uint64_t dynamicCall(void* function,
+                            uintptr_t* arguments,
+                            uint8_t* argumentTypes,
+                            unsigned argumentCount,
+                            unsigned,
+                            unsigned returnType)
 {
   const unsigned GprCount = 6;
   uint64_t gprTable[GprCount];
@@ -192,22 +206,24 @@ dynamicCall(void* function, uintptr_t* arguments, uint8_t* argumentTypes,
     }
   }
 
-  return vmNativeCall(function, stack, stackIndex * BytesPerWord,
+  return vmNativeCall(function,
+                      stack,
+                      stackIndex * BytesPerWord,
                       (gprIndex ? gprTable : 0),
-                      (sseIndex ? sseTable : 0), returnType);
+                      (sseIndex ? sseTable : 0),
+                      returnType);
 }
 #endif
 
-} // namespace vm
+}  // namespace vm
 
 #else
-#  error unsupported architecture
+#error unsupported architecture
 #endif
 
 namespace vm {
 
-inline void
-trap()
+inline void trap()
 {
 #ifdef _MSC_VER
   __asm int 3
@@ -216,50 +232,44 @@ trap()
 #endif
 }
 
-inline void
-programOrderMemoryBarrier()
+inline void programOrderMemoryBarrier()
 {
   compileTimeMemoryBarrier();
 }
 
-inline void
-storeStoreMemoryBarrier()
+inline void storeStoreMemoryBarrier()
 {
   programOrderMemoryBarrier();
 }
 
-inline void
-storeLoadMemoryBarrier()
+inline void storeLoadMemoryBarrier()
 {
 #ifdef _MSC_VER
   MemoryBarrier();
 #elif defined ARCH_x86_32
-  __asm__ __volatile__("lock; addl $0,0(%%esp)": : :"memory");
+  __asm__ __volatile__("lock; addl $0,0(%%esp)" : : : "memory");
 #elif defined ARCH_x86_64
-  __asm__ __volatile__("mfence": : :"memory");
-#endif // ARCH_x86_64
+  __asm__ __volatile__("mfence" : : : "memory");
+#endif  // ARCH_x86_64
 }
 
-inline void
-loadMemoryBarrier()
+inline void loadMemoryBarrier()
 {
   programOrderMemoryBarrier();
 }
 
-inline void
-syncInstructionCache(const void*, unsigned)
+inline void syncInstructionCache(const void*, unsigned)
 {
   programOrderMemoryBarrier();
 }
 
 #ifdef USE_ATOMIC_OPERATIONS
-inline bool
-atomicCompareAndSwap32(uint32_t* p, uint32_t old, uint32_t new_)
+inline bool atomicCompareAndSwap32(uint32_t* p, uint32_t old, uint32_t new_)
 {
 #ifdef _MSC_VER
-  return old == InterlockedCompareExchange
-    (reinterpret_cast<LONG*>(p), new_, old);
-#elif (__GNUC__ >= 4) && (__GNUC_MINOR__ >= 1)
+  return old
+         == InterlockedCompareExchange(reinterpret_cast<LONG*>(p), new_, old);
+#elif(__GNUC__ >= 4) && (__GNUC_MINOR__ >= 1)
   return __sync_bool_compare_and_swap(p, old, new_);
 #else
   uint8_t result;
@@ -275,13 +285,12 @@ atomicCompareAndSwap32(uint32_t* p, uint32_t old, uint32_t new_)
 
 #define AVIAN_HAS_CAS64
 
-inline bool
-atomicCompareAndSwap64(uint64_t* p, uint64_t old, uint64_t new_)
+inline bool atomicCompareAndSwap64(uint64_t* p, uint64_t old, uint64_t new_)
 {
 #ifdef _MSC_VER
-  return old == InterlockedCompareExchange64
-    (reinterpret_cast<LONGLONG*>(p), new_, old);
-#elif (__GNUC__ >= 4) && (__GNUC_MINOR__ >= 1)
+  return old == InterlockedCompareExchange64(
+                    reinterpret_cast<LONGLONG*>(p), new_, old);
+#elif(__GNUC__ >= 4) && (__GNUC_MINOR__ >= 1)
   return __sync_bool_compare_and_swap(p, old, new_);
 #elif defined ARCH_x86_32
   uint8_t result;
@@ -308,17 +317,16 @@ atomicCompareAndSwap64(uint64_t* p, uint64_t old, uint64_t new_)
 #endif
 }
 
-inline bool
-atomicCompareAndSwap(uintptr_t* p, uintptr_t old, uintptr_t new_)
+inline bool atomicCompareAndSwap(uintptr_t* p, uintptr_t old, uintptr_t new_)
 {
 #ifdef ARCH_x86_32
   return atomicCompareAndSwap32(reinterpret_cast<uint32_t*>(p), old, new_);
 #elif defined ARCH_x86_64
   return atomicCompareAndSwap64(reinterpret_cast<uint64_t*>(p), old, new_);
-#endif // ARCH_x86_64
+#endif  // ARCH_x86_64
 }
-#endif // USE_ATOMIC_OPERATIONS
+#endif  // USE_ATOMIC_OPERATIONS
 
-} // namespace vm
+}  // namespace vm
 
-#endif//X86_H
+#endif  // X86_H
diff --git a/src/avian/zlib-custom.h b/src/avian/zlib-custom.h
index 9d749a70a5..de4e05616c 100644
--- a/src/avian/zlib-custom.h
+++ b/src/avian/zlib-custom.h
@@ -13,11 +13,19 @@
 #ifdef inflateInit2
 #undef inflateInit2
 #define inflateInit2(strm, windowBits) \
-        inflateInit2_((strm), (windowBits), ZLIB_VERSION, static_cast<int>(sizeof(z_stream)))
+  inflateInit2_(                       \
+      (strm), (windowBits), ZLIB_VERSION, static_cast<int>(sizeof(z_stream)))
 #endif
 
 #ifdef deflateInit2
 #undef deflateInit2
 #define deflateInit2(strm, level, windowBits) \
-        deflateInit2_((strm), (level), Z_DEFLATED, (windowBits), 8, Z_DEFAULT_STRATEGY, ZLIB_VERSION, static_cast<int>(sizeof(z_stream)))
+  deflateInit2_((strm),                       \
+                (level),                      \
+                Z_DEFLATED,                   \
+                (windowBits),                 \
+                8,                            \
+                Z_DEFAULT_STRATEGY,           \
+                ZLIB_VERSION,                 \
+                static_cast<int>(sizeof(z_stream)))
 #endif
diff --git a/src/avian/zone.h b/src/avian/zone.h
index cc0db700b8..71e80aec90 100644
--- a/src/avian/zone.h
+++ b/src/avian/zone.h
@@ -21,9 +21,9 @@ class Zone : public avian::util::Allocator {
  public:
   class Segment {
    public:
-    Segment(Segment* next, unsigned size):
-      next(next), size(size), position(0)
-    { }
+    Segment(Segment* next, unsigned size) : next(next), size(size), position(0)
+    {
+    }
 
     Segment* next;
     uintptr_t size;
@@ -31,19 +31,23 @@ class Zone : public avian::util::Allocator {
     uint8_t data[0];
   };
 
-  Zone(System* s, Allocator* allocator, unsigned minimumFootprint):
-    s(s),
-    allocator(allocator),
-    segment(0),
-    minimumFootprint(minimumFootprint < sizeof(Segment) ? 0 :
-                     minimumFootprint - sizeof(Segment))
-  { }
+  Zone(System* s, Allocator* allocator, unsigned minimumFootprint)
+      : s(s),
+        allocator(allocator),
+        segment(0),
+        minimumFootprint(minimumFootprint < sizeof(Segment)
+                             ? 0
+                             : minimumFootprint - sizeof(Segment))
+  {
+  }
 
-  ~Zone() {
+  ~Zone()
+  {
     dispose();
   }
 
-  void dispose() {
+  void dispose()
+  {
     for (Segment* seg = segment, *next; seg; seg = next) {
       next = seg->next;
       allocator->free(seg, sizeof(Segment) + seg->size);
@@ -52,18 +56,20 @@ class Zone : public avian::util::Allocator {
     segment = 0;
   }
 
-  static unsigned padToPage(unsigned size) {
-    return (size + (LikelyPageSizeInBytes - 1))
-      & ~(LikelyPageSizeInBytes - 1);
+  static unsigned padToPage(unsigned size)
+  {
+    return (size + (LikelyPageSizeInBytes - 1)) & ~(LikelyPageSizeInBytes - 1);
   }
 
-  bool tryEnsure(unsigned space) {
+  bool tryEnsure(unsigned space)
+  {
     if (segment == 0 or segment->position + space > segment->size) {
-      unsigned size = padToPage
-        (avian::util::max
-         (space, avian::util::max
-          (minimumFootprint, segment == 0 ? 0 : segment->size * 2))
-         + sizeof(Segment));
+      unsigned size = padToPage(
+          avian::util::max(
+              space,
+              avian::util::max(minimumFootprint,
+                               segment == 0 ? 0 : segment->size * 2))
+          + sizeof(Segment));
 
       void* p = allocator->tryAllocate(size);
       if (p == 0) {
@@ -79,16 +85,18 @@ class Zone : public avian::util::Allocator {
     return true;
   }
 
-  void ensure(unsigned space) {
+  void ensure(unsigned space)
+  {
     if (segment == 0 or segment->position + space > segment->size) {
       unsigned size = padToPage(space + sizeof(Segment));
 
       segment = new (allocator->allocate(size))
-        Segment(segment, size - sizeof(Segment));
+          Segment(segment, size - sizeof(Segment));
     }
   }
 
-  virtual void* tryAllocate(unsigned size) {
+  virtual void* tryAllocate(unsigned size)
+  {
     size = pad(size);
     if (tryEnsure(size)) {
       void* r = segment->data + segment->position;
@@ -99,7 +107,8 @@ class Zone : public avian::util::Allocator {
     }
   }
 
-  virtual void* allocate(unsigned size) {
+  virtual void* allocate(unsigned size)
+  {
     size = pad(size);
     void* p = tryAllocate(size);
     if (p) {
@@ -112,7 +121,8 @@ class Zone : public avian::util::Allocator {
     }
   }
 
-  void* peek(unsigned size) {
+  void* peek(unsigned size)
+  {
     size = pad(size);
     Segment* s = segment;
     while (s->position < size) {
@@ -122,7 +132,8 @@ class Zone : public avian::util::Allocator {
     return s->data + (s->position - size);
   }
 
-  void pop(unsigned size) {
+  void pop(unsigned size)
+  {
     size = pad(size);
     Segment* s = segment;
     while (s->position < size) {
@@ -135,11 +146,12 @@ class Zone : public avian::util::Allocator {
     segment = s;
   }
 
-  virtual void free(const void*, unsigned) {
+  virtual void free(const void*, unsigned)
+  {
     // not supported
     abort(s);
   }
-  
+
   System* s;
   Allocator* allocator;
   void* context;
@@ -147,6 +159,6 @@ class Zone : public avian::util::Allocator {
   unsigned minimumFootprint;
 };
 
-} // namespace vm
+}  // namespace vm
 
-#endif//ZONE_H
+#endif  // ZONE_H
diff --git a/src/boot-javahome.cpp b/src/boot-javahome.cpp
index a8df5b4b47..c44fb94b9e 100644
--- a/src/boot-javahome.cpp
+++ b/src/boot-javahome.cpp
@@ -12,26 +12,23 @@
 
 #ifdef BOOT_JAVAHOME
 
-#if (! defined __x86_64__) && ((defined __MINGW32__) || (defined _MSC_VER))
-#  define SYMBOL(x) binary_javahome_jar_##x
+#if (!defined __x86_64__) && ((defined __MINGW32__) || (defined _MSC_VER))
+#define SYMBOL(x) binary_javahome_jar_##x
 #else
-#  define SYMBOL(x) _binary_javahome_jar_##x
+#define SYMBOL(x) _binary_javahome_jar_##x
 #endif
 
 extern "C" {
+extern const uint8_t SYMBOL(start)[];
+extern const uint8_t SYMBOL(end)[];
 
-  extern const uint8_t SYMBOL(start)[];
-  extern const uint8_t SYMBOL(end)[];
-
-  AVIAN_EXPORT const uint8_t*
-  javahomeJar(unsigned* size)
-  {
-    *size = SYMBOL(end) - SYMBOL(start);
-    return SYMBOL(start);
-  }
-
+AVIAN_EXPORT const uint8_t* javahomeJar(unsigned* size)
+{
+  *size = SYMBOL(end) - SYMBOL(start);
+  return SYMBOL(start);
+}
 }
 
 #undef SYMBOL
 
-#endif//BOOT_JAVAHOME
+#endif  // BOOT_JAVAHOME
diff --git a/src/boot.cpp b/src/boot.cpp
index f641751918..f2e0397975 100644
--- a/src/boot.cpp
+++ b/src/boot.cpp
@@ -14,68 +14,64 @@
 
 // since we aren't linking against libstdc++, we must implement this
 // ourselves:
-extern "C" void __cxa_pure_virtual(void) { abort(); }
+extern "C" void __cxa_pure_virtual(void)
+{
+  abort();
+}
 
 #ifdef BOOT_IMAGE
 
-#if (! defined __x86_64__) && ((defined __MINGW32__) || (defined _MSC_VER))
-#  define BOOTIMAGE_SYMBOL(x) binary_bootimage_bin_##x
-#  define CODEIMAGE_SYMBOL(x) binary_codeimage_bin_##x
+#if (!defined __x86_64__) && ((defined __MINGW32__) || (defined _MSC_VER))
+#define BOOTIMAGE_SYMBOL(x) binary_bootimage_bin_##x
+#define CODEIMAGE_SYMBOL(x) binary_codeimage_bin_##x
 #else
-#  define BOOTIMAGE_SYMBOL(x) _binary_bootimage_bin_##x
-#  define CODEIMAGE_SYMBOL(x) _binary_codeimage_bin_##x
+#define BOOTIMAGE_SYMBOL(x) _binary_bootimage_bin_##x
+#define CODEIMAGE_SYMBOL(x) _binary_codeimage_bin_##x
 #endif
 
 extern "C" {
+extern const uint8_t BOOTIMAGE_SYMBOL(start)[];
+extern const uint8_t BOOTIMAGE_SYMBOL(end)[];
 
-  extern const uint8_t BOOTIMAGE_SYMBOL(start)[];
-  extern const uint8_t BOOTIMAGE_SYMBOL(end)[];
+AVIAN_EXPORT const uint8_t* bootimageBin(unsigned* size)
+{
+  *size = BOOTIMAGE_SYMBOL(end) - BOOTIMAGE_SYMBOL(start);
+  return BOOTIMAGE_SYMBOL(start);
+}
 
-  AVIAN_EXPORT const uint8_t*
-  bootimageBin(unsigned* size)
-  {
-    *size = BOOTIMAGE_SYMBOL(end) - BOOTIMAGE_SYMBOL(start);
-    return BOOTIMAGE_SYMBOL(start);
-  }
-
-  extern const uint8_t CODEIMAGE_SYMBOL(start)[];
-  extern const uint8_t CODEIMAGE_SYMBOL(end)[];
-
-  AVIAN_EXPORT const uint8_t*
-  codeimageBin(unsigned* size)
-  {
-    *size = CODEIMAGE_SYMBOL(end) - CODEIMAGE_SYMBOL(start);
-    return CODEIMAGE_SYMBOL(start);
-  }
+extern const uint8_t CODEIMAGE_SYMBOL(start)[];
+extern const uint8_t CODEIMAGE_SYMBOL(end)[];
 
+AVIAN_EXPORT const uint8_t* codeimageBin(unsigned* size)
+{
+  *size = CODEIMAGE_SYMBOL(end) - CODEIMAGE_SYMBOL(start);
+  return CODEIMAGE_SYMBOL(start);
+}
 }
 
 #undef SYMBOL
 
-#endif//BOOT_IMAGE
+#endif  // BOOT_IMAGE
 
 #ifdef BOOT_CLASSPATH
 
-#if (! defined __x86_64__) && ((defined __MINGW32__) || (defined _MSC_VER))
-#  define SYMBOL(x) binary_classpath_jar_##x
+#if (!defined __x86_64__) && ((defined __MINGW32__) || (defined _MSC_VER))
+#define SYMBOL(x) binary_classpath_jar_##x
 #else
-#  define SYMBOL(x) _binary_classpath_jar_##x
+#define SYMBOL(x) _binary_classpath_jar_##x
 #endif
 
 extern "C" {
+extern const uint8_t SYMBOL(start)[];
+extern const uint8_t SYMBOL(end)[];
 
-  extern const uint8_t SYMBOL(start)[];
-  extern const uint8_t SYMBOL(end)[];
-
-  AVIAN_EXPORT const uint8_t*
-  classpathJar(unsigned* size)
-  {
-    *size = SYMBOL(end) - SYMBOL(start);
-    return SYMBOL(start);
-  }
-
+AVIAN_EXPORT const uint8_t* classpathJar(unsigned* size)
+{
+  *size = SYMBOL(end) - SYMBOL(start);
+  return SYMBOL(start);
+}
 }
 
 #undef SYMBOL
 
-#endif//BOOT_CLASSPATH
+#endif  // BOOT_CLASSPATH
diff --git a/src/bootimage-fields.cpp b/src/bootimage-fields.cpp
index a090268de2..761eef88e5 100644
--- a/src/bootimage-fields.cpp
+++ b/src/bootimage-fields.cpp
@@ -1,6 +1,6 @@
 #ifndef FIELD
-#  define FIELD(name)
-#  define FIELD_DEFINED
+#define FIELD(name)
+#define FIELD_DEFINED
 #endif
 
 FIELD(magic)
@@ -23,13 +23,13 @@ FIELD(methodTreeSentinal)
 FIELD(virtualThunks)
 
 #ifdef FIELD_DEFINED
-#  undef FIELD
-#  undef FIELD_DEFINED
+#undef FIELD
+#undef FIELD_DEFINED
 #endif
 
 #ifndef THUNK_FIELD
-#  define THUNK_FIELD(name)
-#  define THUNK_FIELD_DEFINED
+#define THUNK_FIELD(name)
+#define THUNK_FIELD_DEFINED
 #endif
 
 THUNK_FIELD(default_);
@@ -40,6 +40,6 @@ THUNK_FIELD(stackOverflow);
 THUNK_FIELD(table);
 
 #ifdef THUNK_FIELD_DEFINED
-#  undef THUNK_FIELD
-#  undef THUNK_FIELD_DEFINED
+#undef THUNK_FIELD
+#undef THUNK_FIELD_DEFINED
 #endif
diff --git a/src/bootimage-template.cpp b/src/bootimage-template.cpp
index bf32267ece..e8f080cfb2 100644
--- a/src/bootimage-template.cpp
+++ b/src/bootimage-template.cpp
@@ -1,26 +1,25 @@
 const unsigned NAME(BootMask) = (~static_cast<unsigned>(0))
-  / NAME(BytesPerWord);
+                                / NAME(BytesPerWord);
 
 const unsigned NAME(BootShift) = 32 - avian::util::log(NAME(BytesPerWord));
 
 const unsigned NAME(BootFlatConstant) = 1 << NAME(BootShift);
 const unsigned NAME(BootHeapOffset) = 1 << (NAME(BootShift) + 1);
 
-inline unsigned
-LABEL(codeMapSize)(unsigned codeSize)
+inline unsigned LABEL(codeMapSize)(unsigned codeSize)
 {
-  return avian::util::ceilingDivide(codeSize, TargetBitsPerWord) * TargetBytesPerWord;
+  return avian::util::ceilingDivide(codeSize, TargetBitsPerWord)
+         * TargetBytesPerWord;
 }
 
-inline unsigned
-LABEL(heapMapSize)(unsigned heapSize)
+inline unsigned LABEL(heapMapSize)(unsigned heapSize)
 {
-  return avian::util::ceilingDivide(heapSize, TargetBitsPerWord * TargetBytesPerWord)
-    * TargetBytesPerWord;
+  return avian::util::ceilingDivide(heapSize,
+                                    TargetBitsPerWord * TargetBytesPerWord)
+         * TargetBytesPerWord;
 }
 
-inline object
-LABEL(bootObject)(LABEL(uintptr_t)* heap, unsigned offset)
+inline object LABEL(bootObject)(LABEL(uintptr_t) * heap, unsigned offset)
 {
   if (offset) {
     return reinterpret_cast<object>(heap + offset - 1);
diff --git a/src/builtin.cpp b/src/builtin.cpp
index cd33561f32..b6fd26b75e 100644
--- a/src/builtin.cpp
+++ b/src/builtin.cpp
@@ -99,11 +99,10 @@ GcField* fieldForOffset(Thread* t, GcSingleton* o, unsigned offset)
   }
 }
 
-} // namespace
+}  // namespace
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_avian_Classes_initialize
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Classes_initialize(Thread* t, object, uintptr_t* arguments)
 {
   GcClass* this_ = cast<GcClass>(t, reinterpret_cast<object>(arguments[0]));
 
@@ -111,22 +110,19 @@ Avian_avian_Classes_initialize
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_avian_Classes_acquireClassLock
-(Thread* t, object, uintptr_t*)
+    Avian_avian_Classes_acquireClassLock(Thread* t, object, uintptr_t*)
 {
   acquire(t, t->m->classLock);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_avian_Classes_releaseClassLock
-(Thread* t, object, uintptr_t*)
+    Avian_avian_Classes_releaseClassLock(Thread* t, object, uintptr_t*)
 {
   release(t, t->m->classLock);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_Classes_resolveVMClass
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Classes_resolveVMClass(Thread* t, object, uintptr_t* arguments)
 {
   GcClassLoader* loader
       = cast<GcClassLoader>(t, reinterpret_cast<object>(arguments[0]));
@@ -138,8 +134,7 @@ Avian_avian_Classes_resolveVMClass
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_Classes_defineVMClass
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Classes_defineVMClass(Thread* t, object, uintptr_t* arguments)
 {
   GcClassLoader* loader
       = cast<GcClassLoader>(t, reinterpret_cast<object>(arguments[0]));
@@ -147,11 +142,10 @@ Avian_avian_Classes_defineVMClass
   int offset = arguments[2];
   int length = arguments[3];
 
-  uint8_t* buffer = static_cast<uint8_t*>
-    (t->m->heap->allocate(length));
+  uint8_t* buffer = static_cast<uint8_t*>(t->m->heap->allocate(length));
 
-  THREAD_RESOURCE2(t, uint8_t*, buffer, int, length,
-                   t->m->heap->free(buffer, length));
+  THREAD_RESOURCE2(
+      t, uint8_t*, buffer, int, length, t->m->heap->free(buffer, length));
 
   memcpy(buffer, &b->body()[offset], length);
 
@@ -159,8 +153,9 @@ Avian_avian_Classes_defineVMClass
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_SystemClassLoader_findLoadedVMClass
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_SystemClassLoader_findLoadedVMClass(Thread* t,
+                                                    object,
+                                                    uintptr_t* arguments)
 {
   GcClassLoader* loader
       = cast<GcClassLoader>(t, reinterpret_cast<object>(arguments[0]));
@@ -170,16 +165,18 @@ Avian_avian_SystemClassLoader_findLoadedVMClass
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_SystemClassLoader_vmClass
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_SystemClassLoader_vmClass(Thread* t,
+                                          object,
+                                          uintptr_t* arguments)
 {
   return reinterpret_cast<int64_t>(
       cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]))->vmClass());
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_SystemClassLoader_findVMClass
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_SystemClassLoader_findVMClass(Thread* t,
+                                              object,
+                                              uintptr_t* arguments)
 {
   GcClassLoader* loader
       = cast<GcClassLoader>(t, reinterpret_cast<object>(arguments[0]));
@@ -189,8 +186,9 @@ Avian_avian_SystemClassLoader_findVMClass
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_SystemClassLoader_resourceURLPrefix
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_SystemClassLoader_resourceURLPrefix(Thread* t,
+                                                    object,
+                                                    uintptr_t* arguments)
 {
   GcClassLoader* loader
       = cast<GcClassLoader>(t, reinterpret_cast<object>(arguments[0]));
@@ -211,8 +209,10 @@ Avian_avian_SystemClassLoader_resourceURLPrefix
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_SystemClassLoader_00024ResourceEnumeration_nextResourceURLPrefix
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_SystemClassLoader_00024ResourceEnumeration_nextResourceURLPrefix(
+        Thread* t,
+        object,
+        uintptr_t* arguments)
 {
   GcClassLoader* loader
       = cast<GcClassLoader>(t, reinterpret_cast<object>(arguments[1]));
@@ -237,16 +237,18 @@ Avian_avian_SystemClassLoader_00024ResourceEnumeration_nextResourceURLPrefix
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_SystemClassLoader_getClass
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_SystemClassLoader_getClass(Thread* t,
+                                           object,
+                                           uintptr_t* arguments)
 {
   return reinterpret_cast<int64_t>(
       getJClass(t, cast<GcClass>(t, reinterpret_cast<object>(arguments[0]))));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_SystemClassLoader_getPackageSource
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_SystemClassLoader_getPackageSource(Thread* t,
+                                                   object,
+                                                   uintptr_t* arguments)
 {
   GcString* name = cast<GcString>(t, reinterpret_cast<object>(arguments[0]));
   PROTECT(t, name);
@@ -277,8 +279,7 @@ Avian_avian_SystemClassLoader_getPackageSource
 #ifdef AVIAN_HEAPDUMP
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_avian_Machine_dumpHeap
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Machine_dumpHeap(Thread* t, object, uintptr_t* arguments)
 {
   object outputFile = reinterpret_cast<object>(*arguments);
 
@@ -287,7 +288,8 @@ Avian_avian_Machine_dumpHeap
   stringChars(t, outputFile, RUNTIME_ARRAY_BODY(n));
   FILE* out = vm::fopen(RUNTIME_ARRAY_BODY(n), "wb");
   if (out) {
-    { ENTER(t, Thread::ExclusiveState);
+    {
+      ENTER(t, Thread::ExclusiveState);
       dumpHeap(t, out);
     }
     fclose(out);
@@ -299,11 +301,10 @@ Avian_avian_Machine_dumpHeap
   }
 }
 
-#endif//AVIAN_HEAPDUMP
+#endif  // AVIAN_HEAPDUMP
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_Runtime_exit
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Runtime_exit(Thread* t, object, uintptr_t* arguments)
 {
   shutDown(t);
 
@@ -311,22 +312,22 @@ Avian_java_lang_Runtime_exit
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Runtime_freeMemory
-(Thread* t, object, uintptr_t*)
+    Avian_java_lang_Runtime_freeMemory(Thread* t, object, uintptr_t*)
 {
   return t->m->heap->remaining();
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Runtime_totalMemory
-(Thread* t, object, uintptr_t*)
+    Avian_java_lang_Runtime_totalMemory(Thread* t, object, uintptr_t*)
 {
   return t->m->heap->limit();
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_avianvmresource_Handler_00024ResourceInputStream_getContentLength
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_avianvmresource_Handler_00024ResourceInputStream_getContentLength(
+        Thread* t,
+        object,
+        uintptr_t* arguments)
 {
   GcString* path = cast<GcString>(t, reinterpret_cast<object>(*arguments));
 
@@ -349,8 +350,10 @@ Avian_avian_avianvmresource_Handler_00024ResourceInputStream_getContentLength
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_avianvmresource_Handler_00024ResourceInputStream_open
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_avianvmresource_Handler_00024ResourceInputStream_open(
+        Thread* t,
+        object,
+        uintptr_t* arguments)
 {
   GcString* path = cast<GcString>(t, reinterpret_cast<object>(*arguments));
 
@@ -370,10 +373,13 @@ Avian_avian_avianvmresource_Handler_00024ResourceInputStream_open
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_avianvmresource_Handler_00024ResourceInputStream_available
-(Thread*, object, uintptr_t* arguments)
+    Avian_avian_avianvmresource_Handler_00024ResourceInputStream_available(
+        Thread*,
+        object,
+        uintptr_t* arguments)
 {
-  int64_t peer; memcpy(&peer, arguments, 8);
+  int64_t peer;
+  memcpy(&peer, arguments, 8);
   int32_t position = arguments[2];
 
   System::Region* region = reinterpret_cast<System::Region*>(peer);
@@ -381,10 +387,13 @@ Avian_avian_avianvmresource_Handler_00024ResourceInputStream_available
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_avianvmresource_Handler_00024ResourceInputStream_read__JI
-(Thread*, object, uintptr_t* arguments)
+    Avian_avian_avianvmresource_Handler_00024ResourceInputStream_read__JI(
+        Thread*,
+        object,
+        uintptr_t* arguments)
 {
-  int64_t peer; memcpy(&peer, arguments, 8);
+  int64_t peer;
+  memcpy(&peer, arguments, 8);
   int32_t position = arguments[2];
 
   System::Region* region = reinterpret_cast<System::Region*>(peer);
@@ -396,17 +405,21 @@ Avian_avian_avianvmresource_Handler_00024ResourceInputStream_read__JI
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_avianvmresource_Handler_00024ResourceInputStream_read__JI_3BII
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_avianvmresource_Handler_00024ResourceInputStream_read__JI_3BII(
+        Thread* t,
+        object,
+        uintptr_t* arguments)
 {
-  int64_t peer; memcpy(&peer, arguments, 8);
+  int64_t peer;
+  memcpy(&peer, arguments, 8);
   int32_t position = arguments[2];
   GcByteArray* buffer
       = cast<GcByteArray>(t, reinterpret_cast<object>(arguments[3]));
   int32_t offset = arguments[4];
   int32_t length = arguments[5];
 
-  if (length == 0) return 0;
+  if (length == 0)
+    return 0;
 
   System::Region* region = reinterpret_cast<System::Region*>(peer);
   if (length > static_cast<jint>(region->length()) - position) {
@@ -421,38 +434,45 @@ Avian_avian_avianvmresource_Handler_00024ResourceInputStream_read__JI_3BII
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_avian_avianvmresource_Handler_00024ResourceInputStream_close
-(Thread*, object, uintptr_t* arguments)
+    Avian_avian_avianvmresource_Handler_00024ResourceInputStream_close(
+        Thread*,
+        object,
+        uintptr_t* arguments)
 {
-  int64_t peer; memcpy(&peer, arguments, 8);
+  int64_t peer;
+  memcpy(&peer, arguments, 8);
   reinterpret_cast<System::Region*>(peer)->dispose();
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_avian_Continuations_callWithCurrentContinuation
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Continuations_callWithCurrentContinuation(Thread* t,
+                                                          object,
+                                                          uintptr_t* arguments)
 {
-  t->m->processor->callWithCurrentContinuation
-    (t, reinterpret_cast<object>(*arguments));
+  t->m->processor->callWithCurrentContinuation(
+      t, reinterpret_cast<object>(*arguments));
 
   abort(t);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_avian_Continuations_dynamicWind2
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Continuations_dynamicWind2(Thread* t,
+                                           object,
+                                           uintptr_t* arguments)
 {
-  t->m->processor->dynamicWind
-    (t, reinterpret_cast<object>(arguments[0]),
-     reinterpret_cast<object>(arguments[1]),
-     reinterpret_cast<object>(arguments[2]));
+  t->m->processor->dynamicWind(t,
+                               reinterpret_cast<object>(arguments[0]),
+                               reinterpret_cast<object>(arguments[1]),
+                               reinterpret_cast<object>(arguments[2]));
 
   abort(t);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_avian_Continuations_00024Continuation_handleResult
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Continuations_00024Continuation_handleResult(
+        Thread* t,
+        object,
+        uintptr_t* arguments)
 {
   t->m->processor->feedResultToContinuation(
       t,
@@ -463,8 +483,10 @@ Avian_avian_Continuations_00024Continuation_handleResult
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_avian_Continuations_00024Continuation_handleException
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Continuations_00024Continuation_handleException(
+        Thread* t,
+        object,
+        uintptr_t* arguments)
 {
   t->m->processor->feedExceptionToContinuation(
       t,
@@ -475,8 +497,7 @@ Avian_avian_Continuations_00024Continuation_handleException
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_Singleton_getObject
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Singleton_getObject(Thread* t, object, uintptr_t* arguments)
 {
   return reinterpret_cast<int64_t>(singletonObject(
       t,
@@ -485,8 +506,7 @@ Avian_avian_Singleton_getObject
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_Singleton_getInt
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Singleton_getInt(Thread* t, object, uintptr_t* arguments)
 {
   return singletonValue(
       t,
@@ -495,8 +515,7 @@ Avian_avian_Singleton_getInt
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_Singleton_getLong
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Singleton_getLong(Thread* t, object, uintptr_t* arguments)
 {
   int64_t v;
   memcpy(&v,
@@ -509,10 +528,12 @@ Avian_avian_Singleton_getLong
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_allocateMemory
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_allocateMemory(Thread* t,
+                                         object,
+                                         uintptr_t* arguments)
 {
-  int64_t size; memcpy(&size, arguments + 1, 8);
+  int64_t size;
+  memcpy(&size, arguments + 1, 8);
   void* p = malloc(size);
   if (p) {
     return reinterpret_cast<int64_t>(p);
@@ -522,22 +543,23 @@ Avian_sun_misc_Unsafe_allocateMemory
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_freeMemory
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_freeMemory(Thread*, object, uintptr_t* arguments)
 {
-  int64_t p; memcpy(&p, arguments + 1, 8);
+  int64_t p;
+  memcpy(&p, arguments + 1, 8);
   if (p) {
     free(reinterpret_cast<void*>(p));
   }
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_setMemory
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_setMemory(Thread* t, object, uintptr_t* arguments)
 {
   object base = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
-  int64_t count; memcpy(&count, arguments + 4, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
+  int64_t count;
+  memcpy(&count, arguments + 4, 8);
   int8_t value = arguments[6];
 
   PROTECT(t, base);
@@ -556,178 +578,186 @@ Avian_sun_misc_Unsafe_setMemory
 // so these versions will be ignored.
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putByte__JB
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putByte__JB(Thread*, object, uintptr_t* arguments)
 {
-  int64_t p; memcpy(&p, arguments + 1, 8);
+  int64_t p;
+  memcpy(&p, arguments + 1, 8);
   int8_t v = arguments[3];
 
   *reinterpret_cast<int8_t*>(p) = v;
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putShort__JS
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putShort__JS(Thread*, object, uintptr_t* arguments)
 {
-  int64_t p; memcpy(&p, arguments + 1, 8);
+  int64_t p;
+  memcpy(&p, arguments + 1, 8);
   int16_t v = arguments[3];
 
   *reinterpret_cast<int16_t*>(p) = v;
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putChar__JC
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putChar__JC(Thread* t,
+                                      object method,
+                                      uintptr_t* arguments)
 {
   Avian_sun_misc_Unsafe_putShort__JS(t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putInt__JI
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putInt__JI(Thread*, object, uintptr_t* arguments)
 {
-  int64_t p; memcpy(&p, arguments + 1, 8);
+  int64_t p;
+  memcpy(&p, arguments + 1, 8);
   int32_t v = arguments[3];
 
   *reinterpret_cast<int32_t*>(p) = v;
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putFloat__JF
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putFloat__JF(Thread* t,
+                                       object method,
+                                       uintptr_t* arguments)
 {
   Avian_sun_misc_Unsafe_putInt__JI(t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putLong__JJ
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putLong__JJ(Thread*, object, uintptr_t* arguments)
 {
-  int64_t p; memcpy(&p, arguments + 1, 8);
-  int64_t v; memcpy(&v, arguments + 3, 8);
+  int64_t p;
+  memcpy(&p, arguments + 1, 8);
+  int64_t v;
+  memcpy(&v, arguments + 3, 8);
 
   *reinterpret_cast<int64_t*>(p) = v;
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putDouble__JD
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putDouble__JD(Thread* t,
+                                        object method,
+                                        uintptr_t* arguments)
 {
   Avian_sun_misc_Unsafe_putLong__JJ(t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putAddress__JJ
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putAddress__JJ(Thread*, object, uintptr_t* arguments)
 {
-  int64_t p; memcpy(&p, arguments + 1, 8);
-  int64_t v; memcpy(&v, arguments + 3, 8);
+  int64_t p;
+  memcpy(&p, arguments + 1, 8);
+  int64_t v;
+  memcpy(&v, arguments + 3, 8);
 
   *reinterpret_cast<intptr_t*>(p) = v;
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getByte__J
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getByte__J(Thread*, object, uintptr_t* arguments)
 {
-  int64_t p; memcpy(&p, arguments + 1, 8);
+  int64_t p;
+  memcpy(&p, arguments + 1, 8);
 
   return *reinterpret_cast<int8_t*>(p);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getShort__J
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getShort__J(Thread*, object, uintptr_t* arguments)
 {
-  int64_t p; memcpy(&p, arguments + 1, 8);
+  int64_t p;
+  memcpy(&p, arguments + 1, 8);
 
   return *reinterpret_cast<int16_t*>(p);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getChar__J
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getChar__J(Thread* t,
+                                     object method,
+                                     uintptr_t* arguments)
 {
   return Avian_sun_misc_Unsafe_getShort__J(t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getInt__J
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getInt__J(Thread*, object, uintptr_t* arguments)
 {
-  int64_t p; memcpy(&p, arguments + 1, 8);
+  int64_t p;
+  memcpy(&p, arguments + 1, 8);
 
   return *reinterpret_cast<int32_t*>(p);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getFloat__J
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getFloat__J(Thread* t,
+                                      object method,
+                                      uintptr_t* arguments)
 {
   return Avian_sun_misc_Unsafe_getInt__J(t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getLong__J
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getLong__J(Thread*, object, uintptr_t* arguments)
 {
-  int64_t p; memcpy(&p, arguments + 1, 8);
+  int64_t p;
+  memcpy(&p, arguments + 1, 8);
 
   return *reinterpret_cast<int64_t*>(p);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getDouble__J
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getDouble__J(Thread* t,
+                                       object method,
+                                       uintptr_t* arguments)
 {
   return Avian_sun_misc_Unsafe_getLong__J(t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getAddress__J
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getAddress__J(Thread*, object, uintptr_t* arguments)
 {
-  int64_t p; memcpy(&p, arguments + 1, 8);
+  int64_t p;
+  memcpy(&p, arguments + 1, 8);
 
   return *reinterpret_cast<intptr_t*>(p);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_copyMemory
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_copyMemory(Thread* t, object, uintptr_t* arguments)
 {
   object srcBase = reinterpret_cast<object>(arguments[1]);
-  int64_t srcOffset; memcpy(&srcOffset, arguments + 2, 8);
+  int64_t srcOffset;
+  memcpy(&srcOffset, arguments + 2, 8);
   object dstBase = reinterpret_cast<object>(arguments[4]);
-  int64_t dstOffset; memcpy(&dstOffset, arguments + 5, 8);
-  int64_t count; memcpy(&count, arguments + 7, 8);
+  int64_t dstOffset;
+  memcpy(&dstOffset, arguments + 5, 8);
+  int64_t count;
+  memcpy(&count, arguments + 7, 8);
 
   PROTECT(t, srcBase);
   PROTECT(t, dstBase);
 
   ACQUIRE(t, t->m->referenceLock);
 
-  void* src = srcBase
-    ? &fieldAtOffset<uint8_t>(srcBase, srcOffset)
-    : reinterpret_cast<uint8_t*>(srcOffset);
+  void* src = srcBase ? &fieldAtOffset<uint8_t>(srcBase, srcOffset)
+                      : reinterpret_cast<uint8_t*>(srcOffset);
 
-  void* dst = dstBase
-    ? &fieldAtOffset<uint8_t>(dstBase, dstOffset)
-    : reinterpret_cast<uint8_t*>(dstOffset);
+  void* dst = dstBase ? &fieldAtOffset<uint8_t>(dstBase, dstOffset)
+                      : reinterpret_cast<uint8_t*>(dstOffset);
 
   memcpy(dst, src, count);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_arrayBaseOffset
-(Thread*, object, uintptr_t*)
+    Avian_sun_misc_Unsafe_arrayBaseOffset(Thread*, object, uintptr_t*)
 {
   return ArrayBody;
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_arrayIndexScale
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_arrayIndexScale(Thread* t,
+                                          object,
+                                          uintptr_t* arguments)
 {
   GcClass* c
       = cast<GcJclass>(t, reinterpret_cast<object>(arguments[1]))->vmClass();
@@ -745,8 +775,9 @@ Avian_sun_misc_Unsafe_arrayIndexScale
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_nio_FixedArrayByteBuffer_allocateFixed
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_nio_FixedArrayByteBuffer_allocateFixed(Thread* t,
+                                                      object,
+                                                      uintptr_t* arguments)
 {
   int capacity = arguments[0];
   GcLongArray* address
@@ -766,32 +797,34 @@ Avian_java_nio_FixedArrayByteBuffer_allocateFixed
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getObject
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getObject(Thread*, object, uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
 
   return fieldAtOffset<uintptr_t>(o, offset);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putObject
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putObject(Thread* t, object, uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
   uintptr_t value = arguments[4];
 
   setField(t, o, offset, reinterpret_cast<object>(value));
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putObjectVolatile
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putObjectVolatile(Thread* t,
+                                            object,
+                                            uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
   object value = reinterpret_cast<object>(arguments[4]);
 
   storeStoreMemoryBarrier();
@@ -800,18 +833,21 @@ Avian_sun_misc_Unsafe_putObjectVolatile
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putOrderedObject
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putOrderedObject(Thread* t,
+                                           object method,
+                                           uintptr_t* arguments)
 {
   Avian_sun_misc_Unsafe_putObjectVolatile(t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getObjectVolatile
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getObjectVolatile(Thread*,
+                                            object,
+                                            uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
 
   uintptr_t value = fieldAtOffset<uintptr_t>(o, offset);
   loadMemoryBarrier();
@@ -819,16 +855,18 @@ Avian_sun_misc_Unsafe_getObjectVolatile
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_compareAndSwapObject
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_compareAndSwapObject(Thread* t,
+                                               object,
+                                               uintptr_t* arguments)
 {
   object target = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
   uintptr_t expect = arguments[4];
   uintptr_t update = arguments[5];
 
-  bool success = atomicCompareAndSwap
-    (&fieldAtOffset<uintptr_t>(target, offset), expect, update);
+  bool success = atomicCompareAndSwap(
+      &fieldAtOffset<uintptr_t>(target, offset), expect, update);
 
   if (success) {
     mark(t, target, offset);
@@ -838,30 +876,36 @@ Avian_sun_misc_Unsafe_compareAndSwapObject
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_compareAndSwapInt
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_compareAndSwapInt(Thread*,
+                                            object,
+                                            uintptr_t* arguments)
 {
   object target = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
   uint32_t expect = arguments[4];
   uint32_t update = arguments[5];
 
-  return atomicCompareAndSwap32
-    (&fieldAtOffset<uint32_t>(target, offset), expect, update);
+  return atomicCompareAndSwap32(
+      &fieldAtOffset<uint32_t>(target, offset), expect, update);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_compareAndSwapLong
-(Thread* t UNUSED, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_compareAndSwapLong(Thread* t UNUSED,
+                                             object,
+                                             uintptr_t* arguments)
 {
   object target = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
-  uint64_t expect; memcpy(&expect, arguments + 4, 8);
-  uint64_t update; memcpy(&update, arguments + 6, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
+  uint64_t expect;
+  memcpy(&expect, arguments + 4, 8);
+  uint64_t update;
+  memcpy(&update, arguments + 6, 8);
 
 #ifdef AVIAN_HAS_CAS64
-  return atomicCompareAndSwap64
-    (&fieldAtOffset<uint64_t>(target, offset), expect, update);
+  return atomicCompareAndSwap64(
+      &fieldAtOffset<uint64_t>(target, offset), expect, update);
 #else
   PROTECT(t, target);
   ACQUIRE_FIELD_FOR_WRITE(t, fieldForOffset(t, target, offset));
@@ -875,11 +919,13 @@ Avian_sun_misc_Unsafe_compareAndSwapLong
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getLongVolatile
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getLongVolatile(Thread* t,
+                                          object,
+                                          uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
 
   object lock;
   if (BytesPerWord < 8) {
@@ -906,12 +952,15 @@ Avian_sun_misc_Unsafe_getLongVolatile
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putLongVolatile
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putLongVolatile(Thread* t,
+                                          object,
+                                          uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
-  int64_t value; memcpy(&value, arguments + 4, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
+  int64_t value;
+  memcpy(&value, arguments + 4, 8);
 
   object lock;
   if (BytesPerWord < 8) {
@@ -938,8 +987,9 @@ Avian_sun_misc_Unsafe_putLongVolatile
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putOrderedLong
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putOrderedLong(Thread* t,
+                                         object method,
+                                         uintptr_t* arguments)
 {
   // todo: we might be able to use weaker barriers here than
   // putLongVolatile does
@@ -947,8 +997,7 @@ Avian_sun_misc_Unsafe_putOrderedLong
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_unpark
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_unpark(Thread* t, object, uintptr_t* arguments)
 {
   GcThread* thread = cast<GcThread>(t, reinterpret_cast<object>(arguments[1]));
 
@@ -959,11 +1008,11 @@ Avian_sun_misc_Unsafe_unpark
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_park
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_park(Thread* t, object, uintptr_t* arguments)
 {
   bool absolute = arguments[1];
-  int64_t time; memcpy(&time, arguments + 2, 8);
+  int64_t time;
+  memcpy(&time, arguments + 2, 8);
 
   int64_t then = t->m->system->now();
 
@@ -1003,11 +1052,11 @@ Avian_sun_misc_Unsafe_park
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putIntVolatile
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putIntVolatile(Thread*, object, uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
   int32_t value = arguments[4];
 
   storeStoreMemoryBarrier();
@@ -1016,18 +1065,19 @@ Avian_sun_misc_Unsafe_putIntVolatile
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putOrderedInt
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putOrderedInt(Thread* t,
+                                        object method,
+                                        uintptr_t* arguments)
 {
   Avian_sun_misc_Unsafe_putIntVolatile(t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getIntVolatile
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getIntVolatile(Thread*, object, uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
 
   int32_t result = fieldAtOffset<int32_t>(o, offset);
   loadMemoryBarrier();
@@ -1035,11 +1085,11 @@ Avian_sun_misc_Unsafe_getIntVolatile
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putByteVolatile
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putByteVolatile(Thread*, object, uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
   int8_t value = arguments[4];
 
   storeStoreMemoryBarrier();
@@ -1048,11 +1098,11 @@ Avian_sun_misc_Unsafe_putByteVolatile
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getByteVolatile
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getByteVolatile(Thread*, object, uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
 
   int8_t result = fieldAtOffset<int8_t>(o, offset);
   loadMemoryBarrier();
@@ -1060,25 +1110,29 @@ Avian_sun_misc_Unsafe_getByteVolatile
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putBooleanVolatile
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putBooleanVolatile(Thread* t,
+                                             object method,
+                                             uintptr_t* arguments)
 {
   Avian_sun_misc_Unsafe_putByteVolatile(t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getBooleanVolatile
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getBooleanVolatile(Thread* t,
+                                             object method,
+                                             uintptr_t* arguments)
 {
   return Avian_sun_misc_Unsafe_getByteVolatile(t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putShortVolatile
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putShortVolatile(Thread*,
+                                           object,
+                                           uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
   int16_t value = arguments[4];
 
   storeStoreMemoryBarrier();
@@ -1087,11 +1141,13 @@ Avian_sun_misc_Unsafe_putShortVolatile
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getShortVolatile
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getShortVolatile(Thread*,
+                                           object,
+                                           uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
 
   int16_t result = fieldAtOffset<int16_t>(o, offset);
   loadMemoryBarrier();
@@ -1099,57 +1155,63 @@ Avian_sun_misc_Unsafe_getShortVolatile
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putCharVolatile
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putCharVolatile(Thread* t,
+                                          object method,
+                                          uintptr_t* arguments)
 {
   Avian_sun_misc_Unsafe_putShortVolatile(t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getCharVolatile
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getCharVolatile(Thread* t,
+                                          object method,
+                                          uintptr_t* arguments)
 {
   return Avian_sun_misc_Unsafe_getShortVolatile(t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putFloatVolatile
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putFloatVolatile(Thread* t,
+                                           object method,
+                                           uintptr_t* arguments)
 {
   Avian_sun_misc_Unsafe_putIntVolatile(t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getFloatVolatile
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getFloatVolatile(Thread* t,
+                                           object method,
+                                           uintptr_t* arguments)
 {
   return Avian_sun_misc_Unsafe_getIntVolatile(t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putDoubleVolatile
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putDoubleVolatile(Thread* t,
+                                            object method,
+                                            uintptr_t* arguments)
 {
   Avian_sun_misc_Unsafe_putLongVolatile(t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getDoubleVolatile
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getDoubleVolatile(Thread* t,
+                                            object method,
+                                            uintptr_t* arguments)
 {
   return Avian_sun_misc_Unsafe_getLongVolatile(t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_throwException
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_throwException(Thread* t,
+                                         object,
+                                         uintptr_t* arguments)
 {
   vm::throw_(t, cast<GcThrowable>(t, reinterpret_cast<object>(arguments[1])));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_Classes_primitiveClass
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Classes_primitiveClass(Thread* t, object, uintptr_t* arguments)
 {
   return reinterpret_cast<int64_t>(primitiveClass(t, arguments[0]));
 }
diff --git a/src/classpath-android.cpp b/src/classpath-android.cpp
index 4353b151f9..cdd1c4d589 100644
--- a/src/classpath-android.cpp
+++ b/src/classpath-android.cpp
@@ -32,15 +32,13 @@ const char* getErrnoDescription(
 using namespace vm;
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_Classes_defineVMClass
-(Thread*, object, uintptr_t*);
+    Avian_avian_Classes_defineVMClass(Thread*, object, uintptr_t*);
 
 namespace {
 
 namespace local {
 
-void*
-getDirectBufferAddress(Thread* t, object b)
+void* getDirectBufferAddress(Thread* t, object b)
 {
   PROTECT(t, b);
 
@@ -50,8 +48,7 @@ getDirectBufferAddress(Thread* t, object b)
   return reinterpret_cast<void*>(fieldAtOffset<int64_t>(b, field->offset()));
 }
 
-void JNICALL
-loadLibrary(Thread* t, object, uintptr_t* arguments)
+void JNICALL loadLibrary(Thread* t, object, uintptr_t* arguments)
 {
   GcString* name = cast<GcString>(t, reinterpret_cast<object>(arguments[1]));
 
@@ -72,23 +69,19 @@ loadLibrary(Thread* t, object, uintptr_t* arguments)
   }
 }
 
-void JNICALL
-finalizeAllEnqueued(Thread*, object, uintptr_t*)
+void JNICALL finalizeAllEnqueued(Thread*, object, uintptr_t*)
 {
   // ignore
 }
 
-int64_t JNICALL
-appLoader(Thread* t, object, uintptr_t*)
+int64_t JNICALL appLoader(Thread* t, object, uintptr_t*)
 {
   return reinterpret_cast<uintptr_t>(roots(t)->appLoader());
 }
 
-int64_t JNICALL
-defineClass(Thread* t, object method, uintptr_t* arguments)
+int64_t JNICALL defineClass(Thread* t, object method, uintptr_t* arguments)
 {
-  uintptr_t args[]
-    = { arguments[0], arguments[2], arguments[3], arguments[4] };
+  uintptr_t args[] = {arguments[0], arguments[2], arguments[3], arguments[4]};
 
   int64_t v = Avian_avian_Classes_defineVMClass(t, method, args);
 
@@ -97,11 +90,10 @@ defineClass(Thread* t, object method, uintptr_t* arguments)
         getJClass(t, cast<GcClass>(t, reinterpret_cast<object>(v))));
   } else {
     return 0;
-  }  
+  }
 }
 
-int64_t JNICALL
-mapData(Thread*, object, uintptr_t*);
+int64_t JNICALL mapData(Thread*, object, uintptr_t*);
 
 void JNICALL closeMemoryMappedFile(Thread*, GcMethod*, uintptr_t*);
 
@@ -133,17 +125,27 @@ object makeMethodOrConstructor(Thread* t, GcJclass* c, unsigned index)
       t, method->class_()->loader(), method->addendum());
 
   if (method->name()->body()[0] == '<') {
-    return makeJconstructor
-      (t, 0, c, parameterTypes, exceptionTypes, 0, 0, 0, 0, index);
+    return makeJconstructor(
+        t, 0, c, parameterTypes, exceptionTypes, 0, 0, 0, 0, index);
   } else {
     PROTECT(t, exceptionTypes);
 
     GcString* name = t->m->classpath->makeString(
         t, method->name(), 0, method->name()->length() - 1);
 
-    return makeJmethod
-      (t, 0, index, c, name, parameterTypes, exceptionTypes, returnType, 0, 0,
-       0, 0, 0);
+    return makeJmethod(t,
+                       0,
+                       index,
+                       c,
+                       name,
+                       parameterTypes,
+                       exceptionTypes,
+                       returnType,
+                       0,
+                       0,
+                       0,
+                       0,
+                       0);
   }
 }
 
@@ -205,8 +207,7 @@ void initVmThread(Thread* t, GcThread* thread)
                             "Ljava/lang/VMThread;")->offset());
 }
 
-object
-translateStackTrace(Thread* t, object raw)
+object translateStackTrace(Thread* t, object raw)
 {
   PROTECT(t, raw);
 
@@ -230,7 +231,8 @@ class MyClasspath : public Classpath {
  public:
   MyClasspath(Allocator* allocator)
       : allocator(allocator), tzdata(0), mayInitClasses_(false)
-  { }
+  {
+  }
 
   virtual GcJclass* makeJclass(Thread* t, GcClass* class_)
   {
@@ -303,8 +305,8 @@ class MyClasspath : public Classpath {
                         "<init>",
                         "(Ljava/lang/ThreadGroup;Ljava/lang/String;IZ)V");
 
-    t->m->processor->invoke
-      (t, constructor, thread, group, 0, NormalPriority, false);
+    t->m->processor->invoke(
+        t, constructor, thread, group, 0, NormalPriority, false);
 
     thread->setContextClassLoader(t, roots(t)->appLoader());
 
@@ -362,14 +364,12 @@ class MyClasspath : public Classpath {
             ->body()[jfield->slot()]);
   }
 
-  virtual void
-  clearInterrupted(Thread*)
+  virtual void clearInterrupted(Thread*)
   {
     // ignore
   }
 
-  virtual void
-  runThread(Thread* t)
+  virtual void runThread(Thread* t)
   {
     // force monitor creation so we don't get an OutOfMemory error
     // later when we try to acquire it:
@@ -409,8 +409,7 @@ class MyClasspath : public Classpath {
     vm::resolveNative(t, method);
   }
 
-  void
-  interceptMethods(Thread* t, bool updateRuntimeData)
+  void interceptMethods(Thread* t, bool updateRuntimeData)
   {
     {
       GcClass* c
@@ -419,9 +418,12 @@ class MyClasspath : public Classpath {
       if (c) {
         PROTECT(t, c);
 
-        intercept(t, c, "loadLibrary",
+        intercept(t,
+                  c,
+                  "loadLibrary",
                   "(Ljava/lang/String;Ljava/lang/ClassLoader;)V",
-                  voidPointer(loadLibrary), updateRuntimeData);
+                  voidPointer(loadLibrary),
+                  updateRuntimeData);
       }
     }
 
@@ -432,8 +434,12 @@ class MyClasspath : public Classpath {
       if (c) {
         PROTECT(t, c);
 
-        intercept(t, c, "finalizeAllEnqueued", "()V",
-                  voidPointer(finalizeAllEnqueued), updateRuntimeData);
+        intercept(t,
+                  c,
+                  "finalizeAllEnqueued",
+                  "()V",
+                  voidPointer(finalizeAllEnqueued),
+                  updateRuntimeData);
       }
     }
 
@@ -444,12 +450,19 @@ class MyClasspath : public Classpath {
       if (c) {
         PROTECT(t, c);
 
-        intercept(t, c, "createSystemClassLoader", "()Ljava/lang/ClassLoader;",
-                  voidPointer(appLoader), updateRuntimeData);
+        intercept(t,
+                  c,
+                  "createSystemClassLoader",
+                  "()Ljava/lang/ClassLoader;",
+                  voidPointer(appLoader),
+                  updateRuntimeData);
 
-        intercept(t, c, "defineClass",
+        intercept(t,
+                  c,
+                  "defineClass",
                   "(Ljava/lang/String;[BII)Ljava/lang/Class;",
-                  voidPointer(defineClass), updateRuntimeData);
+                  voidPointer(defineClass),
+                  updateRuntimeData);
       }
     }
 
@@ -460,8 +473,12 @@ class MyClasspath : public Classpath {
       if (c) {
         PROTECT(t, c);
 
-        intercept(t, c, "mapData", "()Llibcore/io/MemoryMappedFile;",
-                  voidPointer(mapData), updateRuntimeData);
+        intercept(t,
+                  c,
+                  "mapData",
+                  "()Llibcore/io/MemoryMappedFile;",
+                  voidPointer(mapData),
+                  updateRuntimeData);
       }
     }
 
@@ -472,29 +489,31 @@ class MyClasspath : public Classpath {
       if (c) {
         PROTECT(t, c);
 
-        intercept(t, c, "close", "()V",  voidPointer(closeMemoryMappedFile),
+        intercept(t,
+                  c,
+                  "close",
+                  "()V",
+                  voidPointer(closeMemoryMappedFile),
                   updateRuntimeData);
       }
     }
   }
 
-  virtual void
-  interceptMethods(Thread* t)
+  virtual void interceptMethods(Thread* t)
   {
     interceptMethods(t, false);
   }
 
-  virtual void
-  preBoot(Thread* t)
+  virtual void preBoot(Thread* t)
   {
-    // Android's System.initSystemProperties throws an NPE if
-    // LD_LIBRARY_PATH is not set as of this writing:
+// Android's System.initSystemProperties throws an NPE if
+// LD_LIBRARY_PATH is not set as of this writing:
 #ifdef PLATFORM_WINDOWS
     _wputenv(L"LD_LIBRARY_PATH=(dummy)");
-#elif (! defined AVIAN_IOS)
+#elif(!defined AVIAN_IOS)
     setenv("LD_LIBRARY_PATH", "", false);
 #endif
-    
+
     interceptMethods(t, true);
 
     JniConstants::init(reinterpret_cast<_JNIEnv*>(t));
@@ -509,8 +528,7 @@ class MyClasspath : public Classpath {
     return mayInitClasses_;
   }
 
-  virtual void
-  boot(Thread* t)
+  virtual void boot(Thread* t)
   {
     GcClass* c
         = resolveClass(t, roots(t)->bootLoader(), "java/lang/ClassLoader");
@@ -526,14 +544,12 @@ class MyClasspath : public Classpath {
         t, constructor, roots(t)->appLoader(), roots(t)->bootLoader(), false);
   }
 
-  virtual const char*
-  bootClasspath()
+  virtual const char* bootClasspath()
   {
     return AVIAN_CLASSPATH;
   }
 
-  virtual object
-  makeDirectByteBuffer(Thread* t, void* p, jlong capacity)
+  virtual object makeDirectByteBuffer(Thread* t, void* p, jlong capacity)
   {
     GcClass* c
         = resolveClass(t, roots(t)->bootLoader(), "java/nio/DirectByteBuffer");
@@ -544,21 +560,21 @@ class MyClasspath : public Classpath {
 
     GcMethod* constructor = resolveMethod(t, c, "<init>", "(JI)V");
 
-    t->m->processor->invoke
-      (t, constructor, instance, reinterpret_cast<int64_t>(p),
-       static_cast<int>(capacity));
+    t->m->processor->invoke(t,
+                            constructor,
+                            instance,
+                            reinterpret_cast<int64_t>(p),
+                            static_cast<int>(capacity));
 
     return instance;
   }
 
-  virtual void*
-  getDirectBufferAddress(Thread* t, object b)
+  virtual void* getDirectBufferAddress(Thread* t, object b)
   {
     return local::getDirectBufferAddress(t, b);
   }
 
-  virtual int64_t
-  getDirectBufferCapacity(Thread* t, object b)
+  virtual int64_t getDirectBufferCapacity(Thread* t, object b)
   {
     PROTECT(t, b);
 
@@ -585,14 +601,12 @@ class MyClasspath : public Classpath {
                : caller->class_()->loader();
   }
 
-  virtual void
-  shutDown(Thread*)
+  virtual void shutDown(Thread*)
   {
     // ignore
   }
 
-  virtual void
-  dispose()
+  virtual void dispose()
   {
     if (tzdata) {
       tzdata->dispose();
@@ -605,13 +619,12 @@ class MyClasspath : public Classpath {
   bool mayInitClasses_;
 };
 
-int64_t JNICALL
-mapData(Thread* t, object, uintptr_t*)
+int64_t JNICALL mapData(Thread* t, object, uintptr_t*)
 {
   GcClass* c
       = resolveClass(t, roots(t)->bootLoader(), "libcore/io/MemoryMappedFile");
   PROTECT(t, c);
-  
+
   object instance = makeNew(t, c);
   PROTECT(t, instance);
 
@@ -628,9 +641,11 @@ mapData(Thread* t, object, uintptr_t*)
 
       cp->tzdata = r;
 
-      t->m->processor->invoke
-        (t, constructor, instance, reinterpret_cast<int64_t>(r->start()),
-         static_cast<int64_t>(r->length()));
+      t->m->processor->invoke(t,
+                              constructor,
+                              instance,
+                              reinterpret_cast<int64_t>(r->start()),
+                              static_cast<int64_t>(r->length()));
 
       return reinterpret_cast<uintptr_t>(instance);
     }
@@ -718,7 +733,8 @@ bool matchType(Thread* t, GcField* field, object o)
       return instanceOf(t, resolveClass(t, field->class_()->loader(), spec), o);
     }
 
-  default: abort(t);
+  default:
+    abort(t);
   }
 }
 
@@ -767,7 +783,8 @@ object getField(Thread* t, GcField* field, object instance)
   case ObjectField:
     return fieldAtOffset<object>(target, offset);
 
-  default: abort(t);
+  default:
+    abort(t);
   }
 }
 
@@ -831,28 +848,32 @@ void setField(Thread* t, GcField* field, object instance, object value)
     setField(t, target, offset, value);
     break;
 
-  default: abort(t);
+  default:
+    abort(t);
   }
 }
 
-} // namespace local
+}  // namespace local
 
-} // namespace
+}  // namespace
 
 namespace vm {
 
-Classpath*
-makeClasspath(System*, Allocator* allocator, const char*, const char*)
+Classpath* makeClasspath(System*,
+                         Allocator* allocator,
+                         const char*,
+                         const char*)
 {
   return new (allocator->allocate(sizeof(local::MyClasspath)))
-    local::MyClasspath(allocator);
+      local::MyClasspath(allocator);
 }
 
-} // namespace vm
+}  // namespace vm
 
-extern "C" int
-jniRegisterNativeMethods(JNIEnv* e, const char* className,
-                         const JNINativeMethod* methods, int methodCount)
+extern "C" int jniRegisterNativeMethods(JNIEnv* e,
+                                        const char* className,
+                                        const JNINativeMethod* methods,
+                                        int methodCount)
 {
   jclass c = e->vtable->FindClass(e, className);
 
@@ -865,14 +886,14 @@ jniRegisterNativeMethods(JNIEnv* e, const char* className,
   return 0;
 }
 
-extern "C" void
-jniLogException(JNIEnv*, int, const char*, jthrowable)
+extern "C" void jniLogException(JNIEnv*, int, const char*, jthrowable)
 {
   // ignore
 }
 
-extern "C" int
-jniThrowException(JNIEnv* e, const char* className, const char* message)
+extern "C" int jniThrowException(JNIEnv* e,
+                                 const char* className,
+                                 const char* message)
 {
   jclass c = e->vtable->FindClass(e, className);
 
@@ -883,9 +904,10 @@ jniThrowException(JNIEnv* e, const char* className, const char* message)
   return 0;
 }
 
-extern "C" int
-jniThrowExceptionFmt(JNIEnv* e, const char* className, const char* format,
-                     va_list args)
+extern "C" int jniThrowExceptionFmt(JNIEnv* e,
+                                    const char* className,
+                                    const char* format,
+                                    va_list args)
 {
   const unsigned size = 4096;
   char buffer[size];
@@ -893,26 +915,22 @@ jniThrowExceptionFmt(JNIEnv* e, const char* className, const char* format,
   return jniThrowException(e, className, buffer);
 }
 
-extern "C" int
-jniThrowNullPointerException(JNIEnv* e, const char* message)
+extern "C" int jniThrowNullPointerException(JNIEnv* e, const char* message)
 {
   return jniThrowException(e, "java/lang/NullPointerException", message);
 }
 
-extern "C" int
-jniThrowRuntimeException(JNIEnv* e, const char* message)
+extern "C" int jniThrowRuntimeException(JNIEnv* e, const char* message)
 {
   return jniThrowException(e, "java/lang/RuntimeException", message);
 }
 
-extern "C" int
-jniThrowIOException(JNIEnv* e, const char* message)
+extern "C" int jniThrowIOException(JNIEnv* e, const char* message)
 {
   return jniThrowException(e, "java/lang/IOException", message);
 }
 
-extern "C" const char*
-jniStrError(int error, char* buffer, size_t length)
+extern "C" const char* jniStrError(int error, char* buffer, size_t length)
 {
 #ifdef PLATFORM_WINDOWS
   const char* s = getErrnoDescription(error);
@@ -934,20 +952,20 @@ jniStrError(int error, char* buffer, size_t length)
 /*
  * Android log priority values (as text)
  */
-const char * const androidLogPriorityTitles[] = {
-    "UNKNOWN",
-    "DEFAULT",
-    "VERBOSE",
-    "DEBUG",
-    "INFO",
-    "WARNING",
-    "ERROR",
-    "FATAL",
-    "SILENT"
-};
+const char* const androidLogPriorityTitles[] = {"UNKNOWN",
+                                                "DEFAULT",
+                                                "VERBOSE",
+                                                "DEBUG",
+                                                "INFO",
+                                                "WARNING",
+                                                "ERROR",
+                                                "FATAL",
+                                                "SILENT"};
 
-extern "C" int
-__android_log_print(int priority, const char* tag,  const char* format, ...)
+extern "C" int __android_log_print(int priority,
+                                   const char* tag,
+                                   const char* format,
+                                   ...)
 {
   va_list a;
   const unsigned size = 4096;
@@ -958,45 +976,55 @@ __android_log_print(int priority, const char* tag,  const char* format, ...)
   va_end(a);
 
 #ifndef PLATFORM_WINDOWS
-  return printf("[%s] %s: %s\n", androidLogPriorityTitles[priority], tag, buffer);
+  return printf(
+      "[%s] %s: %s\n", androidLogPriorityTitles[priority], tag, buffer);
 #else
-  return __mingw_fprintf(stderr, "[%s] %s: %s\n", androidLogPriorityTitles[priority], tag, buffer);
+  return __mingw_fprintf(
+      stderr, "[%s] %s: %s\n", androidLogPriorityTitles[priority], tag, buffer);
 #endif
 }
 
-extern "C" int
-jniGetFDFromFileDescriptor(JNIEnv* e, jobject descriptor)
+extern "C" int jniGetFDFromFileDescriptor(JNIEnv* e, jobject descriptor)
 {
-  return e->vtable->GetIntField
-    (e, descriptor, e->vtable->GetFieldID
-     (e, e->vtable->FindClass
-      (e, "java/io/FileDescriptor"), "descriptor", "I"));
+  return e->vtable->GetIntField(
+      e,
+      descriptor,
+      e->vtable->GetFieldID(e,
+                            e->vtable->FindClass(e, "java/io/FileDescriptor"),
+                            "descriptor",
+                            "I"));
 }
 
-extern "C" void
-jniSetFileDescriptorOfFD(JNIEnv* e, jobject descriptor, int value)
+extern "C" void jniSetFileDescriptorOfFD(JNIEnv* e,
+                                         jobject descriptor,
+                                         int value)
 {
-  e->vtable->SetIntField
-    (e, descriptor, e->vtable->GetFieldID
-     (e, e->vtable->FindClass
-      (e, "java/io/FileDescriptor"), "descriptor", "I"), value);
+  e->vtable->SetIntField(
+      e,
+      descriptor,
+      e->vtable->GetFieldID(e,
+                            e->vtable->FindClass(e, "java/io/FileDescriptor"),
+                            "descriptor",
+                            "I"),
+      value);
 }
 
-extern "C" jobject
-jniCreateFileDescriptor(JNIEnv* e, int fd)
+extern "C" jobject jniCreateFileDescriptor(JNIEnv* e, int fd)
 {
-  jobject descriptor = e->vtable->NewObject
-    (e, e->vtable->FindClass(e, "java/io/FileDescriptor"),
-     e->vtable->GetMethodID
-     (e, e->vtable->FindClass(e, "java/io/FileDescriptor"), "<init>", "()V"));
+  jobject descriptor = e->vtable->NewObject(
+      e,
+      e->vtable->FindClass(e, "java/io/FileDescriptor"),
+      e->vtable->GetMethodID(e,
+                             e->vtable->FindClass(e, "java/io/FileDescriptor"),
+                             "<init>",
+                             "()V"));
 
   jniSetFileDescriptorOfFD(e, descriptor, fd);
 
   return descriptor;
 }
 
-int
-register_org_apache_harmony_dalvik_NativeTestTarget(_JNIEnv*)
+int register_org_apache_harmony_dalvik_NativeTestTarget(_JNIEnv*)
 {
   // ignore
   return 0;
@@ -1009,8 +1037,7 @@ int register_java_math_NativeBN(_JNIEnv*)
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_String_compareTo
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_String_compareTo(Thread* t, object, uintptr_t* arguments)
 {
   GcString* a = cast<GcString>(t, reinterpret_cast<object>(arguments[0]));
   GcString* b = cast<GcString>(t, reinterpret_cast<object>(arguments[1]));
@@ -1031,31 +1058,27 @@ Avian_java_lang_String_compareTo
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_String_isEmpty
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_String_isEmpty(Thread* t, object, uintptr_t* arguments)
 {
   return cast<GcString>(t, reinterpret_cast<object>(arguments[0]))->length(t)
          == 0;
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_String_length
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_String_length(Thread* t, object, uintptr_t* arguments)
 {
   return cast<GcString>(t, reinterpret_cast<object>(arguments[0]))->length(t);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_String_intern
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_String_intern(Thread* t, object, uintptr_t* arguments)
 {
-  return reinterpret_cast<intptr_t>
-    (intern(t, reinterpret_cast<object>(arguments[0])));
+  return reinterpret_cast<intptr_t>(
+      intern(t, reinterpret_cast<object>(arguments[0])));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_String_charAt
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_String_charAt(Thread* t, object, uintptr_t* arguments)
 {
   return stringCharAt(t,
                       cast<GcString>(t, reinterpret_cast<object>(arguments[0])),
@@ -1063,17 +1086,15 @@ Avian_java_lang_String_charAt
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_String_equals
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_String_equals(Thread* t, object, uintptr_t* arguments)
 {
-  return arguments[1] and stringEqual
-    (t, reinterpret_cast<object>(arguments[0]),
-     reinterpret_cast<object>(arguments[1]));
+  return arguments[1] and stringEqual(t,
+                                      reinterpret_cast<object>(arguments[0]),
+                                      reinterpret_cast<object>(arguments[1]));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_String_fastIndexOf
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_String_fastIndexOf(Thread* t, object, uintptr_t* arguments)
 {
   GcString* s = cast<GcString>(t, reinterpret_cast<object>(arguments[0]));
   unsigned c = arguments[1];
@@ -1089,8 +1110,7 @@ Avian_java_lang_String_fastIndexOf
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_getInterfaces
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_getInterfaces(Thread* t, object, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]));
 
@@ -1120,8 +1140,9 @@ Avian_java_lang_Class_getInterfaces
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_getDeclaredClasses
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_getDeclaredClasses(Thread* t,
+                                             object,
+                                             uintptr_t* arguments)
 {
   return reinterpret_cast<intptr_t>(getDeclaredClasses(
       t,
@@ -1130,16 +1151,18 @@ Avian_java_lang_Class_getDeclaredClasses
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_getDeclaringClass
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_getDeclaringClass(Thread* t,
+                                            object,
+                                            uintptr_t* arguments)
 {
   return reinterpret_cast<intptr_t>(getDeclaringClass(
       t, cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]))->vmClass()));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_getEnclosingMethod
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_getEnclosingMethod(Thread* t,
+                                             object,
+                                             uintptr_t* arguments)
 {
   GcClass* c
       = cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]))->vmClass();
@@ -1177,15 +1200,17 @@ Avian_java_lang_Class_getEnclosingMethod
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_getEnclosingConstructor
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_java_lang_Class_getEnclosingConstructor(Thread* t,
+                                                  object method,
+                                                  uintptr_t* arguments)
 {
   return Avian_java_lang_Class_getEnclosingMethod(t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_newInstanceImpl
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_newInstanceImpl(Thread* t,
+                                          object,
+                                          uintptr_t* arguments)
 {
   GcClass* c
       = cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]))->vmClass();
@@ -1202,16 +1227,16 @@ Avian_java_lang_Class_newInstanceImpl
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_getComponentType
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_getComponentType(Thread* t,
+                                           object,
+                                           uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]));
 
   if (c->vmClass()->arrayDimensions()) {
     uint8_t n = c->vmClass()->name()->body()[1];
     if (n != 'L' and n != '[') {
-      return reinterpret_cast<uintptr_t>
-        (getJClass(t, primitiveClass(t, n)));
+      return reinterpret_cast<uintptr_t>(getJClass(t, primitiveClass(t, n)));
     } else {
       return reinterpret_cast<uintptr_t>(
           getJClass(t, c->vmClass()->arrayElementClass()));
@@ -1222,8 +1247,7 @@ Avian_java_lang_Class_getComponentType
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_classForName
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_classForName(Thread* t, object, uintptr_t* arguments)
 {
   object name = reinterpret_cast<object>(arguments[0]);
   PROTECT(t, name);
@@ -1239,14 +1263,14 @@ Avian_java_lang_Class_classForName
       "forName",
       "(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;");
 
-  return reinterpret_cast<uintptr_t>
-    (t->m->processor->invoke
-     (t, method, 0, name, static_cast<int>(arguments[1]), loader));
+  return reinterpret_cast<uintptr_t>(t->m->processor->invoke(
+      t, method, 0, name, static_cast<int>(arguments[1]), loader));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_getDeclaredField
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_getDeclaredField(Thread* t,
+                                           object,
+                                           uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]));
   PROTECT(t, c);
@@ -1272,8 +1296,9 @@ Avian_java_lang_Class_getDeclaredField
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_getDeclaredConstructorOrMethod
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_getDeclaredConstructorOrMethod(Thread* t,
+                                                         object,
+                                                         uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]));
   PROTECT(t, c);
@@ -1297,23 +1322,25 @@ Avian_java_lang_Class_getDeclaredConstructorOrMethod
                   ->value();
 
   if (index >= 0) {
-    return reinterpret_cast<uintptr_t>
-      (local::makeMethodOrConstructor(t, c, index));
+    return reinterpret_cast<uintptr_t>(
+        local::makeMethodOrConstructor(t, c, index));
   } else {
     return 0;
   }
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_SystemClassLoader_findLoadedVMClass
-(Thread*, object, uintptr_t*);
+    Avian_avian_SystemClassLoader_findLoadedVMClass(Thread*,
+                                                    object,
+                                                    uintptr_t*);
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_VMClassLoader_findLoadedClass
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_java_lang_VMClassLoader_findLoadedClass(Thread* t,
+                                                  object method,
+                                                  uintptr_t* arguments)
 {
-  int64_t v = Avian_avian_SystemClassLoader_findLoadedVMClass
-    (t, method, arguments);
+  int64_t v
+      = Avian_avian_SystemClassLoader_findLoadedVMClass(t, method, arguments);
 
   if (v) {
     return reinterpret_cast<uintptr_t>(
@@ -1324,11 +1351,12 @@ Avian_java_lang_VMClassLoader_findLoadedClass
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_VMClassLoader_defineClass__Ljava_lang_ClassLoader_2Ljava_lang_String_2_3BII
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_java_lang_VMClassLoader_defineClass__Ljava_lang_ClassLoader_2Ljava_lang_String_2_3BII(
+        Thread* t,
+        object method,
+        uintptr_t* arguments)
 {
-  uintptr_t args[]
-    = { arguments[0], arguments[2], arguments[3], arguments[4] };
+  uintptr_t args[] = {arguments[0], arguments[2], arguments[3], arguments[4]};
 
   int64_t v = Avian_avian_Classes_defineVMClass(t, method, args);
 
@@ -1341,29 +1369,25 @@ Avian_java_lang_VMClassLoader_defineClass__Ljava_lang_ClassLoader_2Ljava_lang_St
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_dalvik_system_VMRuntime_bootClassPath
-(Thread* t, object, uintptr_t*)
+    Avian_dalvik_system_VMRuntime_bootClassPath(Thread* t, object, uintptr_t*)
 {
   return reinterpret_cast<uintptr_t>(roots(t)->bootLoader());
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_dalvik_system_VMRuntime_classPath
-(Thread* t, object, uintptr_t*)
+    Avian_dalvik_system_VMRuntime_classPath(Thread* t, object, uintptr_t*)
 {
   return reinterpret_cast<uintptr_t>(roots(t)->appLoader());
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_dalvik_system_VMRuntime_vmVersion
-(Thread* t, object, uintptr_t*)
+    Avian_dalvik_system_VMRuntime_vmVersion(Thread* t, object, uintptr_t*)
 {
   return reinterpret_cast<uintptr_t>(makeString(t, "%s", AVIAN_VERSION));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_dalvik_system_VMRuntime_properties
-(Thread* t, object, uintptr_t*)
+    Avian_dalvik_system_VMRuntime_properties(Thread* t, object, uintptr_t*)
 {
   object array
       = makeObjectArray(t, type(t, GcString::Type), t->m->propertyCount + 1);
@@ -1388,15 +1412,13 @@ Avian_dalvik_system_VMRuntime_properties
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_Runtime_gc
-(Thread* t, object, uintptr_t*)
+    Avian_java_lang_Runtime_gc(Thread* t, object, uintptr_t*)
 {
   collect(t, Heap::MajorCollection);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Runtime_nativeLoad
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Runtime_nativeLoad(Thread* t, object, uintptr_t* arguments)
 {
   GcString* name = cast<GcString>(t, reinterpret_cast<object>(arguments[0]));
   PROTECT(t, name);
@@ -1413,10 +1435,10 @@ Avian_java_lang_Runtime_nativeLoad
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_System_arraycopy
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_System_arraycopy(Thread* t, object, uintptr_t* arguments)
 {
-  arrayCopy(t, reinterpret_cast<object>(arguments[0]),
+  arrayCopy(t,
+            reinterpret_cast<object>(arguments[0]),
             arguments[1],
             reinterpret_cast<object>(arguments[2]),
             arguments[3],
@@ -1424,8 +1446,9 @@ Avian_java_lang_System_arraycopy
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_objectFieldOffset
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_objectFieldOffset(Thread* t,
+                                            object,
+                                            uintptr_t* arguments)
 {
   GcJfield* jfield = cast<GcJfield>(t, reinterpret_cast<object>(arguments[1]));
   return cast<GcField>(
@@ -1435,8 +1458,7 @@ Avian_sun_misc_Unsafe_objectFieldOffset
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_VMThread_interrupt
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_VMThread_interrupt(Thread* t, object, uintptr_t* arguments)
 {
   object vmThread = reinterpret_cast<object>(arguments[0]);
   PROTECT(t, vmThread);
@@ -1452,15 +1474,15 @@ Avian_java_lang_VMThread_interrupt
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_VMThread_interrupted
-(Thread* t, object, uintptr_t*)
+    Avian_java_lang_VMThread_interrupted(Thread* t, object, uintptr_t*)
 {
   return getAndClearInterrupted(t, t);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_VMThread_isInterrupted
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_VMThread_isInterrupted(Thread* t,
+                                           object,
+                                           uintptr_t* arguments)
 {
   object vmThread = reinterpret_cast<object>(arguments[0]);
   PROTECT(t, vmThread);
@@ -1473,23 +1495,20 @@ Avian_java_lang_VMThread_isInterrupted
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_VMThread_getStatus
-(Thread*, object, uintptr_t*)
+    Avian_java_lang_VMThread_getStatus(Thread*, object, uintptr_t*)
 {
   // todo
   return 1;
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_VMThread_currentThread
-(Thread* t, object, uintptr_t*)
+    Avian_java_lang_VMThread_currentThread(Thread* t, object, uintptr_t*)
 {
   return reinterpret_cast<uintptr_t>(t->javaThread);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_VMThread_create
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_VMThread_create(Thread* t, object, uintptr_t* arguments)
 {
   GcThread* thread = cast<GcThread>(t, reinterpret_cast<object>(arguments[0]));
   PROTECT(t, thread);
@@ -1499,12 +1518,14 @@ Avian_java_lang_VMThread_create
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_VMThread_sleep
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_VMThread_sleep(Thread* t, object, uintptr_t* arguments)
 {
-  int64_t milliseconds; memcpy(&milliseconds, arguments, 8);
-  if (arguments[2] > 0) ++ milliseconds;
-  if (milliseconds <= 0) milliseconds = 1;
+  int64_t milliseconds;
+  memcpy(&milliseconds, arguments, 8);
+  if (arguments[2] > 0)
+    ++milliseconds;
+  if (milliseconds <= 0)
+    milliseconds = 1;
 
   if (t->javaThread->sleepLock() == 0) {
     object lock = makeJobject(t);
@@ -1517,30 +1538,30 @@ Avian_java_lang_VMThread_sleep
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_dalvik_system_VMStack_getThreadStackTrace
-(Thread* t, object, uintptr_t* arguments)
+    Avian_dalvik_system_VMStack_getThreadStackTrace(Thread* t,
+                                                    object,
+                                                    uintptr_t* arguments)
 {
   Thread* p = reinterpret_cast<Thread*>(
       cast<GcThread>(t, reinterpret_cast<object>(arguments[0]))->peer());
 
-  return reinterpret_cast<uintptr_t>
-    (local::translateStackTrace
-     (t, p == t
-      ? makeTrace(t)
-      : t->m->processor->getStackTrace(t, p)));
+  return reinterpret_cast<uintptr_t>(local::translateStackTrace(
+      t, p == t ? makeTrace(t) : t->m->processor->getStackTrace(t, p)));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_dalvik_system_VMStack_getCallingClassLoader
-(Thread* t, object, uintptr_t*)
+    Avian_dalvik_system_VMStack_getCallingClassLoader(Thread* t,
+                                                      object,
+                                                      uintptr_t*)
 {
-  class Visitor: public Processor::StackVisitor {
+  class Visitor : public Processor::StackVisitor {
    public:
-    Visitor(Thread* t):
-    t(t), loader(0), counter(2)
-    { }
+    Visitor(Thread* t) : t(t), loader(0), counter(2)
+    {
+    }
 
-    virtual bool visit(Processor::StackWalker* walker) {
+    virtual bool visit(Processor::StackWalker* walker)
+    {
       if (counter--) {
         return true;
       } else {
@@ -1560,16 +1581,16 @@ Avian_dalvik_system_VMStack_getCallingClassLoader
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_dalvik_system_VMStack_getClasses
-(Thread* t, object, uintptr_t*)
+    Avian_dalvik_system_VMStack_getClasses(Thread* t, object, uintptr_t*)
 {
-  class Visitor: public Processor::StackVisitor {
+  class Visitor : public Processor::StackVisitor {
    public:
-    Visitor(Thread* t):
-    t(t), array(0), counter(0)
-    { }
+    Visitor(Thread* t) : t(t), array(0), counter(0)
+    {
+    }
 
-    virtual bool visit(Processor::StackWalker* walker) {
+    virtual bool visit(Processor::StackWalker* walker)
+    {
       if (counter < 2) {
         return true;
       } else {
@@ -1586,7 +1607,7 @@ Avian_dalvik_system_VMStack_getClasses
         return true;
       }
 
-      ++ counter;
+      ++counter;
     }
 
     Thread* t;
@@ -1603,78 +1624,70 @@ Avian_dalvik_system_VMStack_getClasses
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Math_min
-(Thread*, object, uintptr_t* arguments)
+    Avian_java_lang_Math_min(Thread*, object, uintptr_t* arguments)
 {
   return min(static_cast<int>(arguments[0]), static_cast<int>(arguments[1]));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Math_max
-(Thread*, object, uintptr_t* arguments)
+    Avian_java_lang_Math_max(Thread*, object, uintptr_t* arguments)
 {
   return max(static_cast<int>(arguments[0]), static_cast<int>(arguments[1]));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Math_cos
-(Thread*, object, uintptr_t* arguments)
+    Avian_java_lang_Math_cos(Thread*, object, uintptr_t* arguments)
 {
-  int64_t v; memcpy(&v, arguments, 8);
+  int64_t v;
+  memcpy(&v, arguments, 8);
   return doubleToBits(cos(bitsToDouble(v)));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Math_sin
-(Thread*, object, uintptr_t* arguments)
+    Avian_java_lang_Math_sin(Thread*, object, uintptr_t* arguments)
 {
-  int64_t v; memcpy(&v, arguments, 8);
+  int64_t v;
+  memcpy(&v, arguments, 8);
   return doubleToBits(sin(bitsToDouble(v)));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Math_sqrt
-(Thread*, object, uintptr_t* arguments)
+    Avian_java_lang_Math_sqrt(Thread*, object, uintptr_t* arguments)
 {
-  int64_t v; memcpy(&v, arguments, 8);
+  int64_t v;
+  memcpy(&v, arguments, 8);
   return doubleToBits(sqrt(bitsToDouble(v)));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Math_abs__I
-(Thread*, object, uintptr_t* arguments)
+    Avian_java_lang_Math_abs__I(Thread*, object, uintptr_t* arguments)
 {
   return abs(static_cast<int32_t>(arguments[0]));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Math_abs__J
-(Thread*, object, uintptr_t* arguments)
+    Avian_java_lang_Math_abs__J(Thread*, object, uintptr_t* arguments)
 {
   return llabs(arguments[0]);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Math_abs__F
-(Thread*, object, uintptr_t* arguments)
+    Avian_java_lang_Math_abs__F(Thread*, object, uintptr_t* arguments)
 {
   return floatToBits(abs(bitsToFloat(arguments[0])));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Float_intBitsToFloat
-(Thread*, object, uintptr_t* arguments)
+    Avian_java_lang_Float_intBitsToFloat(Thread*, object, uintptr_t* arguments)
 {
   return arguments[0];
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Float_floatToIntBits
-(Thread*, object, uintptr_t* arguments)
+    Avian_java_lang_Float_floatToIntBits(Thread*, object, uintptr_t* arguments)
 {
   if (((arguments[0] & 0x7F800000) == 0x7F800000)
-      and ((arguments[0] & 0x007FFFFF) != 0))
-  {
+      and ((arguments[0] & 0x007FFFFF) != 0)) {
     return 0x7fc00000;
   } else {
     return arguments[0];
@@ -1682,10 +1695,12 @@ Avian_java_lang_Float_floatToIntBits
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Double_doubleToRawLongBits
-(Thread*, object, uintptr_t* arguments)
+    Avian_java_lang_Double_doubleToRawLongBits(Thread*,
+                                               object,
+                                               uintptr_t* arguments)
 {
-  int64_t v; memcpy(&v, arguments, 8);
+  int64_t v;
+  memcpy(&v, arguments, 8);
   // todo: do we need to do NaN checks as in
   // Avian_java_lang_Float_floatToIntBits above?  If so, update
   // Double.doubleToRawLongBits in the Avian class library too.
@@ -1693,55 +1708,51 @@ Avian_java_lang_Double_doubleToRawLongBits
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_Object_wait
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Object_wait(Thread* t, object, uintptr_t* arguments)
 {
-  jlong milliseconds; memcpy(&milliseconds, arguments + 1, sizeof(jlong));
+  jlong milliseconds;
+  memcpy(&milliseconds, arguments + 1, sizeof(jlong));
 
   wait(t, reinterpret_cast<object>(arguments[0]), milliseconds);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_Object_notifyAll
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Object_notifyAll(Thread* t, object, uintptr_t* arguments)
 {
   notifyAll(t, reinterpret_cast<object>(arguments[0]));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Object_getClass
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Object_getClass(Thread* t, object, uintptr_t* arguments)
 {
-  return reinterpret_cast<uintptr_t>
-    (getJClass(t, objectClass(t, reinterpret_cast<object>(arguments[0]))));
+  return reinterpret_cast<uintptr_t>(
+      getJClass(t, objectClass(t, reinterpret_cast<object>(arguments[0]))));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Object_hashCode
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Object_hashCode(Thread* t, object, uintptr_t* arguments)
 {
   return objectHash(t, reinterpret_cast<object>(arguments[0]));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Object_internalClone
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Object_internalClone(Thread* t,
+                                         object,
+                                         uintptr_t* arguments)
 {
-  return reinterpret_cast<uintptr_t>
-    (clone(t, reinterpret_cast<object>(arguments[1])));
+  return reinterpret_cast<uintptr_t>(
+      clone(t, reinterpret_cast<object>(arguments[1])));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_getModifiers
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_getModifiers(Thread* t, object, uintptr_t* arguments)
 {
   return classModifiers(
       t, cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]))->vmClass());
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_getSuperclass
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_getSuperclass(Thread* t, object, uintptr_t* arguments)
 {
   GcClass* c
       = cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]))->vmClass();
@@ -1754,15 +1765,13 @@ Avian_java_lang_Class_getSuperclass
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_desiredAssertionStatus
-(Thread*, object, uintptr_t*)
+    Avian_java_lang_Class_desiredAssertionStatus(Thread*, object, uintptr_t*)
 {
   return 1;
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_getNameNative
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_getNameNative(Thread* t, object, uintptr_t* arguments)
 {
   GcByteArray* name = cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]))
                           ->vmClass()
@@ -1774,13 +1783,12 @@ Avian_java_lang_Class_getNameNative
           RUNTIME_ARRAY_BODY(s),
           reinterpret_cast<char*>(name->body().begin()));
 
-  return reinterpret_cast<uintptr_t>
-    (makeString(t, "%s", RUNTIME_ARRAY_BODY(s)));
+  return reinterpret_cast<uintptr_t>(
+      makeString(t, "%s", RUNTIME_ARRAY_BODY(s)));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_isInterface
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_isInterface(Thread* t, object, uintptr_t* arguments)
 {
   return (cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]))
               ->vmClass()
@@ -1788,8 +1796,7 @@ Avian_java_lang_Class_isInterface
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_isPrimitive
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_isPrimitive(Thread* t, object, uintptr_t* arguments)
 {
   return (cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]))
               ->vmClass()
@@ -1797,8 +1804,9 @@ Avian_java_lang_Class_isPrimitive
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_isAnonymousClass
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_isAnonymousClass(Thread* t,
+                                           object,
+                                           uintptr_t* arguments)
 {
   GcByteArray* name = cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]))
                           ->vmClass()
@@ -1815,8 +1823,9 @@ Avian_java_lang_Class_isAnonymousClass
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_getClassLoader
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_getClassLoader(Thread* t,
+                                         object,
+                                         uintptr_t* arguments)
 {
   return reinterpret_cast<uintptr_t>(
       cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]))
@@ -1825,8 +1834,9 @@ Avian_java_lang_Class_getClassLoader
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_isAssignableFrom
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_isAssignableFrom(Thread* t,
+                                           object,
+                                           uintptr_t* arguments)
 {
   GcJclass* this_ = cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]));
   GcJclass* that = cast<GcJclass>(t, reinterpret_cast<object>(arguments[1]));
@@ -1839,8 +1849,7 @@ Avian_java_lang_Class_isAssignableFrom
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_isInstance
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_isInstance(Thread* t, object, uintptr_t* arguments)
 {
   GcJclass* this_ = cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]));
   object o = reinterpret_cast<object>(arguments[1]);
@@ -1853,8 +1862,9 @@ Avian_java_lang_Class_isInstance
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_getDeclaredMethods
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_getDeclaredMethods(Thread* t,
+                                             object,
+                                             uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]));
   PROTECT(t, c);
@@ -1873,8 +1883,9 @@ Avian_java_lang_Class_getDeclaredMethods
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_getDeclaredFields
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_getDeclaredFields(Thread* t,
+                                            object,
+                                            uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]));
   PROTECT(t, c);
@@ -1892,8 +1903,9 @@ Avian_java_lang_Class_getDeclaredFields
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Method_invokeNative
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Method_invokeNative(Thread* t,
+                                                object,
+                                                uintptr_t* arguments)
 {
   object instance = reinterpret_cast<object>(arguments[1]);
   object args = reinterpret_cast<object>(arguments[2]);
@@ -1908,8 +1920,9 @@ Avian_java_lang_reflect_Method_invokeNative
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Method_getMethodModifiers
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Method_getMethodModifiers(Thread* t,
+                                                      object,
+                                                      uintptr_t* arguments)
 {
   return cast<GcMethod>(
              t,
@@ -1921,8 +1934,9 @@ Avian_java_lang_reflect_Method_getMethodModifiers
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Method_isAnnotationPresent
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Method_isAnnotationPresent(Thread* t,
+                                                       object,
+                                                       uintptr_t* arguments)
 {
   GcMethod* method = cast<GcMethod>(
       t,
@@ -1937,8 +1951,7 @@ Avian_java_lang_reflect_Method_isAnnotationPresent
     if (table) {
       for (unsigned i = 0; i < objectArrayLength(t, table); ++i) {
         if (objectArrayBody(t, objectArrayBody(t, table, i), 1)
-            == reinterpret_cast<object>(arguments[2]))
-        {
+            == reinterpret_cast<object>(arguments[2])) {
           return true;
         }
       }
@@ -1949,8 +1962,9 @@ Avian_java_lang_reflect_Method_isAnnotationPresent
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Method_getAnnotation
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Method_getAnnotation(Thread* t,
+                                                 object,
+                                                 uintptr_t* arguments)
 {
   GcMethod* method = cast<GcMethod>(
       t,
@@ -1965,8 +1979,7 @@ Avian_java_lang_reflect_Method_getAnnotation
     if (table) {
       for (unsigned i = 0; i < objectArrayLength(t, table); ++i) {
         if (objectArrayBody(t, objectArrayBody(t, table, i), 1)
-            == reinterpret_cast<object>(arguments[2]))
-        {
+            == reinterpret_cast<object>(arguments[2])) {
           PROTECT(t, method);
           PROTECT(t, table);
 
@@ -1993,8 +2006,9 @@ Avian_java_lang_reflect_Method_getAnnotation
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Method_getDeclaredAnnotations
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Method_getDeclaredAnnotations(Thread* t,
+                                                          object,
+                                                          uintptr_t* arguments)
 {
   GcMethod* method = cast<GcMethod>(
       t,
@@ -2105,8 +2119,9 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Method_getDefaultValue
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Method_getDefaultValue(Thread* t,
+                                                   object,
+                                                   uintptr_t* arguments)
 {
   GcMethod* method = cast<GcMethod>(
       t,
@@ -2133,8 +2148,9 @@ Avian_java_lang_reflect_Method_getDefaultValue
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Constructor_constructNative
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Constructor_constructNative(Thread* t,
+                                                        object,
+                                                        uintptr_t* arguments)
 {
   object args = reinterpret_cast<object>(arguments[1]);
   PROTECT(t, args);
@@ -2158,8 +2174,9 @@ Avian_java_lang_reflect_Constructor_constructNative
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Field_getField
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Field_getField(Thread* t,
+                                           object,
+                                           uintptr_t* arguments)
 {
   GcField* field = cast<GcField>(
       t,
@@ -2177,8 +2194,9 @@ Avian_java_lang_reflect_Field_getField
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Field_getIField
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Field_getIField(Thread* t,
+                                            object,
+                                            uintptr_t* arguments)
 {
   GcField* field = cast<GcField>(
       t,
@@ -2196,8 +2214,9 @@ Avian_java_lang_reflect_Field_getIField
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Field_getJField
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Field_getJField(Thread* t,
+                                            object,
+                                            uintptr_t* arguments)
 {
   GcField* field = cast<GcField>(
       t,
@@ -2215,8 +2234,9 @@ Avian_java_lang_reflect_Field_getJField
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_reflect_Field_setField
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Field_setField(Thread* t,
+                                           object,
+                                           uintptr_t* arguments)
 {
   GcField* field = cast<GcField>(
       t,
@@ -2237,8 +2257,9 @@ Avian_java_lang_reflect_Field_setField
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_reflect_Field_setIField
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Field_setIField(Thread* t,
+                                            object,
+                                            uintptr_t* arguments)
 {
   GcField* field = cast<GcField>(
       t,
@@ -2256,8 +2277,9 @@ Avian_java_lang_reflect_Field_setIField
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Field_getFieldModifiers
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Field_getFieldModifiers(Thread* t,
+                                                    object,
+                                                    uintptr_t* arguments)
 {
   return cast<GcField>(
              t,
@@ -2269,8 +2291,9 @@ Avian_java_lang_reflect_Field_getFieldModifiers
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Field_getAnnotation
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Field_getAnnotation(Thread* t,
+                                                object,
+                                                uintptr_t* arguments)
 {
   GcField* field = cast<GcField>(
       t,
@@ -2285,8 +2308,7 @@ Avian_java_lang_reflect_Field_getAnnotation
     if (table) {
       for (unsigned i = 0; i < objectArrayLength(t, table); ++i) {
         if (objectArrayBody(t, objectArrayBody(t, table, i), 1)
-            == reinterpret_cast<object>(arguments[2]))
-        {
+            == reinterpret_cast<object>(arguments[2])) {
           PROTECT(t, field);
           PROTECT(t, table);
 
@@ -2313,8 +2335,9 @@ Avian_java_lang_reflect_Field_getAnnotation
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Field_getSignatureAnnotation
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Field_getSignatureAnnotation(Thread* t,
+                                                         object,
+                                                         uintptr_t* arguments)
 {
   GcField* field = cast<GcField>(
       t,
@@ -2343,23 +2366,24 @@ Avian_java_lang_reflect_Field_getSignatureAnnotation
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Throwable_nativeFillInStackTrace
-(Thread* t, object, uintptr_t*)
+    Avian_java_lang_Throwable_nativeFillInStackTrace(Thread* t,
+                                                     object,
+                                                     uintptr_t*)
 {
   return reinterpret_cast<uintptr_t>(getTrace(t, 2));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Throwable_nativeGetStackTrace
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Throwable_nativeGetStackTrace(Thread* t,
+                                                  object,
+                                                  uintptr_t* arguments)
 {
-  return reinterpret_cast<uintptr_t>
-    (local::translateStackTrace(t, reinterpret_cast<object>(arguments[0])));
+  return reinterpret_cast<uintptr_t>(
+      local::translateStackTrace(t, reinterpret_cast<object>(arguments[0])));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_Classes_makeMethod
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Classes_makeMethod(Thread* t, object, uintptr_t* arguments)
 {
   return reinterpret_cast<uintptr_t>(local::makeMethodOrConstructor(
       t,
@@ -2368,8 +2392,7 @@ Avian_avian_Classes_makeMethod
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_Classes_makeField
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Classes_makeField(Thread* t, object, uintptr_t* arguments)
 {
   return reinterpret_cast<uintptr_t>(local::makeField(
       t,
@@ -2378,8 +2401,9 @@ Avian_avian_Classes_makeField
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Array_createObjectArray
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Array_createObjectArray(Thread* t,
+                                                    object,
+                                                    uintptr_t* arguments)
 {
   return reinterpret_cast<uintptr_t>(makeObjectArray(
       t,
@@ -2388,15 +2412,15 @@ Avian_java_lang_reflect_Array_createObjectArray
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_nio_ByteOrder_isLittleEndian
-(Thread*, object, uintptr_t*)
+    Avian_java_nio_ByteOrder_isLittleEndian(Thread*, object, uintptr_t*)
 {
   return true;
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_dalvik_system_VMRuntime_newNonMovableArray
-(Thread* t, object, uintptr_t* arguments)
+    Avian_dalvik_system_VMRuntime_newNonMovableArray(Thread* t,
+                                                     object,
+                                                     uintptr_t* arguments)
 {
   if (cast<GcJclass>(t, reinterpret_cast<object>(arguments[1]))->vmClass()
       == type(t, GcJbyte::Type)) {
@@ -2418,18 +2442,20 @@ Avian_dalvik_system_VMRuntime_newNonMovableArray
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_dalvik_system_VMRuntime_addressOf
-(Thread*, object, uintptr_t* arguments)
+    Avian_dalvik_system_VMRuntime_addressOf(Thread*,
+                                            object,
+                                            uintptr_t* arguments)
 {
   return arguments[1] + ArrayBody;
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_libcore_io_Memory_pokeLong
-(Thread*, object, uintptr_t* arguments)
+    Avian_libcore_io_Memory_pokeLong(Thread*, object, uintptr_t* arguments)
 {
-  int64_t address; memcpy(&address, arguments, 8);
-  int64_t v; memcpy(&v, arguments + 2, 8);
+  int64_t address;
+  memcpy(&address, arguments, 8);
+  int64_t v;
+  memcpy(&v, arguments + 2, 8);
   if (arguments[4]) {
     v = swapV8(v);
   }
@@ -2437,106 +2463,117 @@ Avian_libcore_io_Memory_pokeLong
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_libcore_io_Memory_peekLong
-(Thread*, object, uintptr_t* arguments)
+    Avian_libcore_io_Memory_peekLong(Thread*, object, uintptr_t* arguments)
 {
-  int64_t address; memcpy(&address, arguments, 8);
-  int64_t v; memcpy(&v, reinterpret_cast<void*>(address), 8);
+  int64_t address;
+  memcpy(&address, arguments, 8);
+  int64_t v;
+  memcpy(&v, reinterpret_cast<void*>(address), 8);
   return arguments[2] ? swapV8(v) : v;
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_libcore_io_Memory_pokeInt
-(Thread*, object, uintptr_t* arguments)
+    Avian_libcore_io_Memory_pokeInt(Thread*, object, uintptr_t* arguments)
 {
-  int64_t address; memcpy(&address, arguments, 8);
+  int64_t address;
+  memcpy(&address, arguments, 8);
   int32_t v = arguments[3] ? swapV4(arguments[2]) : arguments[2];
   memcpy(reinterpret_cast<void*>(address), &v, 4);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_libcore_io_Memory_peekInt
-(Thread*, object, uintptr_t* arguments)
+    Avian_libcore_io_Memory_peekInt(Thread*, object, uintptr_t* arguments)
 {
-  int64_t address; memcpy(&address, arguments, 8);
-  int32_t v; memcpy(&v, reinterpret_cast<void*>(address), 4);
+  int64_t address;
+  memcpy(&address, arguments, 8);
+  int32_t v;
+  memcpy(&v, reinterpret_cast<void*>(address), 4);
   return arguments[2] ? swapV4(v) : v;
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_libcore_io_Memory_pokeShort
-(Thread*, object, uintptr_t* arguments)
+    Avian_libcore_io_Memory_pokeShort(Thread*, object, uintptr_t* arguments)
 {
-  int64_t address; memcpy(&address, arguments, 8);
+  int64_t address;
+  memcpy(&address, arguments, 8);
   int16_t v = arguments[3] ? swapV2(arguments[2]) : arguments[2];
   memcpy(reinterpret_cast<void*>(address), &v, 2);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_libcore_io_Memory_peekShort
-(Thread*, object, uintptr_t* arguments)
+    Avian_libcore_io_Memory_peekShort(Thread*, object, uintptr_t* arguments)
 {
-  int64_t address; memcpy(&address, arguments, 8);
-  int16_t v; memcpy(&v, reinterpret_cast<void*>(address), 2);
+  int64_t address;
+  memcpy(&address, arguments, 8);
+  int16_t v;
+  memcpy(&v, reinterpret_cast<void*>(address), 2);
   return arguments[2] ? swapV2(v) : v;
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_libcore_io_Memory_pokeByte
-(Thread*, object, uintptr_t* arguments)
+    Avian_libcore_io_Memory_pokeByte(Thread*, object, uintptr_t* arguments)
 {
-  int64_t address; memcpy(&address, arguments, 8);
+  int64_t address;
+  memcpy(&address, arguments, 8);
   *reinterpret_cast<int8_t*>(address) = arguments[2];
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_libcore_io_Memory_peekByte
-(Thread*, object, uintptr_t* arguments)
+    Avian_libcore_io_Memory_peekByte(Thread*, object, uintptr_t* arguments)
 {
-  int64_t address; memcpy(&address, arguments, 8);
+  int64_t address;
+  memcpy(&address, arguments, 8);
   return *reinterpret_cast<int8_t*>(address);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_System_nanoTime
-(Thread* t, object, uintptr_t*)
+    Avian_java_lang_System_nanoTime(Thread* t, object, uintptr_t*)
 {
   return t->m->system->now() * 1000 * 1000;
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_System_currentTimeMillis
-(Thread* t, object, uintptr_t*)
+    Avian_java_lang_System_currentTimeMillis(Thread* t, object, uintptr_t*)
 {
   return t->m->system->now();
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_System_identityHashCode
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_System_identityHashCode(Thread* t,
+                                            object,
+                                            uintptr_t* arguments)
 {
   return objectHash(t, reinterpret_cast<object>(arguments[0]));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8
-(Thread*, object, uintptr_t*)
+    Avian_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(Thread*,
+                                                               object,
+                                                               uintptr_t*)
 {
   return true;
 }
 
 #ifdef PLATFORM_WINDOWS
 
-#  include <io.h>
+#include <io.h>
 
-void register_java_io_Console(_JNIEnv*) { }
-void register_java_lang_ProcessManager(_JNIEnv*) { }
-void register_libcore_net_RawSocket(_JNIEnv*) { }
-//void register_org_apache_harmony_xnet_provider_jsse_NativeCrypto(_JNIEnv*) { }
+void register_java_io_Console(_JNIEnv*)
+{
+}
+void register_java_lang_ProcessManager(_JNIEnv*)
+{
+}
+void register_libcore_net_RawSocket(_JNIEnv*)
+{
+}
+// void register_org_apache_harmony_xnet_provider_jsse_NativeCrypto(_JNIEnv*) {
+// }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_libcore_io_OsConstants_initConstants
-(Thread* t, object method, uintptr_t*)
+    Avian_libcore_io_OsConstants_initConstants(Thread* t,
+                                               object method,
+                                               uintptr_t*)
 {
   object c = method->class_();
   PROTECT(t, c);
@@ -2555,41 +2592,41 @@ Avian_libcore_io_OsConstants_initConstants
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_libcore_io_Posix_getenv(Thread* t, object, uintptr_t* arguments)
+    Avian_libcore_io_Posix_getenv(Thread* t, object, uintptr_t* arguments)
 {
   object name = reinterpret_cast<object>(arguments[1]);
 
   THREAD_RUNTIME_ARRAY(t, uint16_t, chars, name->length(t) + 1);
   stringChars(t, name, RUNTIME_ARRAY_BODY(chars));
 
-  wchar_t* value = _wgetenv
-    (reinterpret_cast<wchar_t*>(RUNTIME_ARRAY_BODY(chars)));
+  wchar_t* value
+      = _wgetenv(reinterpret_cast<wchar_t*>(RUNTIME_ARRAY_BODY(chars)));
 
   if (value) {
     unsigned size = wcslen(value);
-    
+
     object a = makeCharArray(t, size);
     if (size) {
       memcpy(&charArrayBody(t, a, 0), value, size * sizeof(jchar));
     }
-    
-    return reinterpret_cast<uintptr_t>
-      (t->m->classpath->makeString(t, a, 0, size));
+
+    return reinterpret_cast<uintptr_t>(
+        t->m->classpath->makeString(t, a, 0, size));
   } else {
     return 0;
   }
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_libcore_io_Posix_uname(Thread* t, object, uintptr_t*)
+    Avian_libcore_io_Posix_uname(Thread* t, object, uintptr_t*)
 {
   GcClass* c
       = resolveClass(t, roots(t)->bootLoader(), "libcore/io/StructUtsname");
   PROTECT(t, c);
-  
+
   object instance = makeNew(t, c);
   PROTECT(t, instance);
-  
+
 #ifdef ARCH_x86_32
   object arch = makeString(t, "x86");
 #elif defined ARCH_x86_64
@@ -2600,24 +2637,30 @@ Avian_libcore_io_Posix_uname(Thread* t, object, uintptr_t*)
   object arch = makeString(t, "unknown");
 #endif
 
-  set(t, instance, fieldOffset
-      (t, resolveField(t, c, "machine", "Ljava/lang/String;")), arch);
+  set(t,
+      instance,
+      fieldOffset(t, resolveField(t, c, "machine", "Ljava/lang/String;")),
+      arch);
 
   object platform = makeString(t, "Windows");
 
-  set(t, instance, fieldOffset
-      (t, resolveField(t, c, "sysname", "Ljava/lang/String;")), platform);
+  set(t,
+      instance,
+      fieldOffset(t, resolveField(t, c, "sysname", "Ljava/lang/String;")),
+      platform);
 
   object version = makeString(t, "unknown");
 
-  set(t, instance, fieldOffset
-      (t, resolveField(t, c, "release", "Ljava/lang/String;")), version);
+  set(t,
+      instance,
+      fieldOffset(t, resolveField(t, c, "release", "Ljava/lang/String;")),
+      version);
 
   return reinterpret_cast<uintptr_t>(instance);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_libcore_io_Posix_writeBytes(Thread* t, object, uintptr_t* arguments)
+    Avian_libcore_io_Posix_writeBytes(Thread* t, object, uintptr_t* arguments)
 {
   object fd = reinterpret_cast<object>(arguments[1]);
   PROTECT(t, fd);
@@ -2634,13 +2677,15 @@ Avian_libcore_io_Posix_writeBytes(Thread* t, object, uintptr_t* arguments)
   if (objectClass(t, buffer) == type(t, GcByteArray::Type)) {
     void* tmp = t->m->heap->allocate(count);
     memcpy(tmp, &byteArrayBody(t, buffer, offset), count);
-    { ENTER(t, Thread::IdleState);
+    {
+      ENTER(t, Thread::IdleState);
       r = _write(d, tmp, count);
     }
     t->m->heap->free(tmp, count);
   } else {
     void* p = local::getDirectBufferAddress(t, buffer);
-    { ENTER(t, Thread::IdleState);
+    {
+      ENTER(t, Thread::IdleState);
       r = _write(d, p, count);
     }
   }
diff --git a/src/classpath-avian.cpp b/src/classpath-avian.cpp
index 94bab270d5..86626215d2 100644
--- a/src/classpath-avian.cpp
+++ b/src/classpath-avian.cpp
@@ -22,9 +22,9 @@ namespace local {
 
 class MyClasspath : public Classpath {
  public:
-  MyClasspath(Allocator* allocator):
-    allocator(allocator)
-  { }
+  MyClasspath(Allocator* allocator) : allocator(allocator)
+  {
+  }
 
   virtual GcJclass* makeJclass(Thread* t, GcClass* class_)
   {
@@ -97,14 +97,12 @@ class MyClasspath : public Classpath {
     return jfield->vmField();
   }
 
-  virtual void
-  clearInterrupted(Thread*)
+  virtual void clearInterrupted(Thread*)
   {
     // ignore
   }
 
-  virtual void
-  runThread(Thread* t)
+  virtual void runThread(Thread* t)
   {
     GcMethod* method = resolveMethod(t,
                                      roots(t)->bootLoader(),
@@ -120,14 +118,12 @@ class MyClasspath : public Classpath {
     vm::resolveNative(t, method);
   }
 
-  virtual void
-  interceptMethods(Thread*)
+  virtual void interceptMethods(Thread*)
   {
     // ignore
   }
 
-  virtual void
-  preBoot(Thread*)
+  virtual void preBoot(Thread*)
   {
     // ignore
   }
@@ -137,20 +133,17 @@ class MyClasspath : public Classpath {
     return true;
   }
 
-  virtual void
-  boot(Thread*)
+  virtual void boot(Thread*)
   {
     // ignore
   }
 
-  virtual const char*
-  bootClasspath()
+  virtual const char* bootClasspath()
   {
     return AVIAN_CLASSPATH;
   }
 
-  virtual object
-  makeDirectByteBuffer(Thread* t, void* p, jlong capacity)
+  virtual object makeDirectByteBuffer(Thread* t, void* p, jlong capacity)
   {
     GcClass* c
         = resolveClass(t, roots(t)->bootLoader(), "java/nio/DirectByteBuffer");
@@ -161,15 +154,16 @@ class MyClasspath : public Classpath {
 
     GcMethod* constructor = resolveMethod(t, c, "<init>", "(JI)V");
 
-    t->m->processor->invoke
-      (t, constructor, instance, reinterpret_cast<int64_t>(p),
-       static_cast<int32_t>(capacity));
+    t->m->processor->invoke(t,
+                            constructor,
+                            instance,
+                            reinterpret_cast<int64_t>(p),
+                            static_cast<int32_t>(capacity));
 
     return instance;
   }
 
-  virtual void*
-  getDirectBufferAddress(Thread* t, object b)
+  virtual void* getDirectBufferAddress(Thread* t, object b)
   {
     PROTECT(t, b);
 
@@ -178,8 +172,7 @@ class MyClasspath : public Classpath {
     return reinterpret_cast<void*>(fieldAtOffset<int64_t>(b, field->offset()));
   }
 
-  virtual int64_t
-  getDirectBufferCapacity(Thread* t, object b)
+  virtual int64_t getDirectBufferCapacity(Thread* t, object b)
   {
     PROTECT(t, b);
 
@@ -219,14 +212,12 @@ class MyClasspath : public Classpath {
                : caller->class_()->loader();
   }
 
-  virtual void
-  shutDown(Thread*)
+  virtual void shutDown(Thread*)
   {
     // ignore
   }
 
-  virtual void
-  dispose()
+  virtual void dispose()
   {
     allocator->free(this, sizeof(*this));
   }
@@ -242,32 +233,35 @@ void enumerateThreads(Thread* t,
 {
   if (*index < limit) {
     array->setBodyElement(t, *index, x->javaThread);
-    ++ (*index);
+    ++(*index);
 
-    if (x->peer) enumerateThreads(t, x->peer, array, index, limit);
-    
-    if (x->child) enumerateThreads(t, x->child, array, index, limit);
+    if (x->peer)
+      enumerateThreads(t, x->peer, array, index, limit);
+
+    if (x->child)
+      enumerateThreads(t, x->child, array, index, limit);
   }
 }
 
-} // namespace local
+}  // namespace local
 
-} // namespace
+}  // namespace
 
 namespace vm {
 
-Classpath*
-makeClasspath(System*, Allocator* allocator, const char*, const char*)
+Classpath* makeClasspath(System*,
+                         Allocator* allocator,
+                         const char*,
+                         const char*)
 {
   return new (allocator->allocate(sizeof(local::MyClasspath)))
-    local::MyClasspath(allocator);
+      local::MyClasspath(allocator);
 }
 
-} // namespace vm
+}  // namespace vm
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Object_toString
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Object_toString(Thread* t, object, uintptr_t* arguments)
 {
   object this_ = reinterpret_cast<object>(arguments[0]);
 
@@ -279,26 +273,24 @@ Avian_java_lang_Object_toString
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Object_getVMClass
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Object_getVMClass(Thread* t, object, uintptr_t* arguments)
 {
-  return reinterpret_cast<int64_t>
-    (objectClass(t, reinterpret_cast<object>(arguments[0])));
+  return reinterpret_cast<int64_t>(
+      objectClass(t, reinterpret_cast<object>(arguments[0])));
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_Object_wait
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Object_wait(Thread* t, object, uintptr_t* arguments)
 {
   object this_ = reinterpret_cast<object>(arguments[0]);
-  int64_t milliseconds; memcpy(&milliseconds, arguments + 1, 8);
+  int64_t milliseconds;
+  memcpy(&milliseconds, arguments + 1, 8);
 
   vm::wait(t, this_, milliseconds);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_Object_notify
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Object_notify(Thread* t, object, uintptr_t* arguments)
 {
   object this_ = reinterpret_cast<object>(arguments[0]);
 
@@ -306,8 +298,7 @@ Avian_java_lang_Object_notify
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_Object_notifyAll
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Object_notifyAll(Thread* t, object, uintptr_t* arguments)
 {
   object this_ = reinterpret_cast<object>(arguments[0]);
 
@@ -315,8 +306,7 @@ Avian_java_lang_Object_notifyAll
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Object_hashCode
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Object_hashCode(Thread* t, object, uintptr_t* arguments)
 {
   object this_ = reinterpret_cast<object>(arguments[0]);
 
@@ -324,16 +314,16 @@ Avian_java_lang_Object_hashCode
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Object_clone
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Object_clone(Thread* t, object, uintptr_t* arguments)
 {
-  return reinterpret_cast<int64_t>
-    (clone(t, reinterpret_cast<object>(arguments[0])));
+  return reinterpret_cast<int64_t>(
+      clone(t, reinterpret_cast<object>(arguments[0])));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_io_ObjectInputStream_makeInstance
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_io_ObjectInputStream_makeInstance(Thread* t,
+                                                 object,
+                                                 uintptr_t* arguments)
 {
   GcClass* c = cast<GcClass>(t, reinterpret_cast<object>(arguments[0]));
 
@@ -341,36 +331,38 @@ Avian_java_io_ObjectInputStream_makeInstance
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_LegacyObjectInputStream_makeInstance
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_LegacyObjectInputStream_makeInstance(Thread* t,
+                                                     object,
+                                                     uintptr_t* arguments)
 {
   return Avian_java_io_ObjectInputStream_makeInstance(t, NULL, arguments);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Field_getPrimitive
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Field_getPrimitive(Thread* t,
+                                               object,
+                                               uintptr_t* arguments)
 {
   object instance = reinterpret_cast<object>(arguments[0]);
   int code = arguments[1];
   int offset = arguments[2];
 
   switch (code) {
-  case ByteField: 
+  case ByteField:
     return fieldAtOffset<int8_t>(instance, offset);
-  case BooleanField: 
+  case BooleanField:
     return fieldAtOffset<uint8_t>(instance, offset);
-  case CharField: 
+  case CharField:
     return fieldAtOffset<uint16_t>(instance, offset);
-  case ShortField: 
+  case ShortField:
     return fieldAtOffset<int16_t>(instance, offset);
-  case IntField: 
+  case IntField:
     return fieldAtOffset<int32_t>(instance, offset);
-  case LongField: 
+  case LongField:
     return fieldAtOffset<int64_t>(instance, offset);
-  case FloatField: 
+  case FloatField:
     return fieldAtOffset<uint32_t>(instance, offset);
-  case DoubleField: 
+  case DoubleField:
     return fieldAtOffset<uint64_t>(instance, offset);
   default:
     abort(t);
@@ -378,8 +370,9 @@ Avian_java_lang_reflect_Field_getPrimitive
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Field_getObject
-(Thread*, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Field_getObject(Thread*,
+                                            object,
+                                            uintptr_t* arguments)
 {
   object instance = reinterpret_cast<object>(arguments[0]);
   int offset = arguments[1];
@@ -388,13 +381,15 @@ Avian_java_lang_reflect_Field_getObject
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_reflect_Field_setPrimitive
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Field_setPrimitive(Thread* t,
+                                               object,
+                                               uintptr_t* arguments)
 {
   object instance = reinterpret_cast<object>(arguments[0]);
   int code = arguments[1];
   int offset = arguments[2];
-  int64_t value; memcpy(&value, arguments + 3, 8);
+  int64_t value;
+  memcpy(&value, arguments + 3, 8);
 
   switch (code) {
   case ByteField:
@@ -409,16 +404,16 @@ Avian_java_lang_reflect_Field_setPrimitive
   case ShortField:
     fieldAtOffset<int16_t>(instance, offset) = static_cast<int16_t>(value);
     break;
-  case IntField: 
+  case IntField:
     fieldAtOffset<int32_t>(instance, offset) = static_cast<int32_t>(value);
     break;
-  case LongField: 
+  case LongField:
     fieldAtOffset<int64_t>(instance, offset) = static_cast<int64_t>(value);
     break;
-  case FloatField: 
+  case FloatField:
     fieldAtOffset<uint32_t>(instance, offset) = static_cast<uint32_t>(value);
     break;
-  case DoubleField: 
+  case DoubleField:
     fieldAtOffset<uint64_t>(instance, offset) = static_cast<uint64_t>(value);
     break;
   default:
@@ -427,8 +422,9 @@ Avian_java_lang_reflect_Field_setPrimitive
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_reflect_Field_setObject
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Field_setObject(Thread* t,
+                                            object,
+                                            uintptr_t* arguments)
 {
   object instance = reinterpret_cast<object>(arguments[0]);
   int offset = arguments[1];
@@ -438,8 +434,9 @@ Avian_java_lang_reflect_Field_setObject
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Constructor_make
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Constructor_make(Thread* t,
+                                             object,
+                                             uintptr_t* arguments)
 {
   GcClass* c = cast<GcClass>(t, reinterpret_cast<object>(arguments[0]));
 
@@ -447,38 +444,38 @@ Avian_java_lang_reflect_Constructor_make
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Method_getCaller
-(Thread* t, object, uintptr_t*)
+    Avian_java_lang_reflect_Method_getCaller(Thread* t, object, uintptr_t*)
 {
   return reinterpret_cast<int64_t>(getCaller(t, 2));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Method_invoke
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Method_invoke(Thread* t,
+                                          object,
+                                          uintptr_t* arguments)
 {
   GcMethod* method = cast<GcMethod>(t, reinterpret_cast<object>(arguments[0]));
   object instance = reinterpret_cast<object>(arguments[1]);
   object args = reinterpret_cast<object>(arguments[2]);
 
   THREAD_RESOURCE0(t, {
-      if (t->exception) {
-        GcThrowable* exception = t->exception;
-        t->exception = makeThrowable(
-            t, GcInvocationTargetException::Type, 0, 0, exception);
-      }
-    });
+    if (t->exception) {
+      GcThrowable* exception = t->exception;
+      t->exception = makeThrowable(
+          t, GcInvocationTargetException::Type, 0, 0, exception);
+    }
+  });
 
   unsigned returnCode = method->returnCode();
 
-  return reinterpret_cast<int64_t>
-    (translateInvokeResult
-     (t, returnCode, t->m->processor->invokeArray(t, method, instance, args)));
+  return reinterpret_cast<int64_t>(translateInvokeResult(
+      t, returnCode, t->m->processor->invokeArray(t, method, instance, args)));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Array_getLength
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Array_getLength(Thread* t,
+                                            object,
+                                            uintptr_t* arguments)
 {
   object array = reinterpret_cast<object>(arguments[0]);
 
@@ -496,8 +493,9 @@ Avian_java_lang_reflect_Array_getLength
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_reflect_Array_makeObjectArray
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_reflect_Array_makeObjectArray(Thread* t,
+                                                  object,
+                                                  uintptr_t* arguments)
 {
   GcJclass* elementType
       = cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]));
@@ -508,38 +506,41 @@ Avian_java_lang_reflect_Array_makeObjectArray
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Float_floatToRawIntBits
-(Thread*, object, uintptr_t* arguments)
+    Avian_java_lang_Float_floatToRawIntBits(Thread*,
+                                            object,
+                                            uintptr_t* arguments)
 {
   return static_cast<int32_t>(*arguments);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Float_intBitsToFloat
-(Thread*, object, uintptr_t* arguments)
+    Avian_java_lang_Float_intBitsToFloat(Thread*, object, uintptr_t* arguments)
 {
   return static_cast<int32_t>(*arguments);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Double_doubleToRawLongBits
-(Thread*, object, uintptr_t* arguments)
+    Avian_java_lang_Double_doubleToRawLongBits(Thread*,
+                                               object,
+                                               uintptr_t* arguments)
 {
-  int64_t v; memcpy(&v, arguments, 8);
+  int64_t v;
+  memcpy(&v, arguments, 8);
   return v;
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Double_longBitsToDouble
-(Thread*, object, uintptr_t* arguments)
+    Avian_java_lang_Double_longBitsToDouble(Thread*,
+                                            object,
+                                            uintptr_t* arguments)
 {
-  int64_t v; memcpy(&v, arguments, 8);
+  int64_t v;
+  memcpy(&v, arguments, 8);
   return v;
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_String_intern
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_String_intern(Thread* t, object, uintptr_t* arguments)
 {
   object this_ = reinterpret_cast<object>(arguments[0]);
 
@@ -562,10 +563,10 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_System_arraycopy
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_System_arraycopy(Thread* t, object, uintptr_t* arguments)
 {
-  arrayCopy(t, reinterpret_cast<object>(arguments[0]),
+  arrayCopy(t,
+            reinterpret_cast<object>(arguments[0]),
             arguments[1],
             reinterpret_cast<object>(arguments[2]),
             arguments[3],
@@ -573,8 +574,9 @@ Avian_java_lang_System_arraycopy
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_System_identityHashCode
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_System_identityHashCode(Thread* t,
+                                            object,
+                                            uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[0]);
 
@@ -612,15 +614,15 @@ extern "C" AVIAN_EXPORT void JNICALL
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_Runtime_gc
-(Thread* t, object, uintptr_t*)
+    Avian_java_lang_Runtime_gc(Thread* t, object, uintptr_t*)
 {
   collect(t, Heap::MajorCollection);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_Runtime_addShutdownHook
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Runtime_addShutdownHook(Thread* t,
+                                            object,
+                                            uintptr_t* arguments)
 {
   object hook = reinterpret_cast<object>(arguments[1]);
   PROTECT(t, hook);
@@ -633,15 +635,15 @@ Avian_java_lang_Runtime_addShutdownHook
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Throwable_trace
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Throwable_trace(Thread* t, object, uintptr_t* arguments)
 {
   return reinterpret_cast<int64_t>(getTrace(t, arguments[0]));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Throwable_resolveTrace
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Throwable_resolveTrace(Thread* t,
+                                           object,
+                                           uintptr_t* arguments)
 {
   object trace = reinterpret_cast<object>(*arguments);
   PROTECT(t, trace);
@@ -661,63 +663,61 @@ Avian_java_lang_Throwable_resolveTrace
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Thread_currentThread
-(Thread* t, object, uintptr_t*)
+    Avian_java_lang_Thread_currentThread(Thread* t, object, uintptr_t*)
 {
   return reinterpret_cast<int64_t>(t->javaThread);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Thread_doStart
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Thread_doStart(Thread* t, object, uintptr_t* arguments)
 {
   return reinterpret_cast<int64_t>(
       startThread(t, cast<GcThread>(t, reinterpret_cast<object>(*arguments))));
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_Thread_interrupt
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Thread_interrupt(Thread* t, object, uintptr_t* arguments)
 {
-  int64_t peer; memcpy(&peer, arguments, 8);
+  int64_t peer;
+  memcpy(&peer, arguments, 8);
 
   threadInterrupt(t, reinterpret_cast<Thread*>(peer)->javaThread);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Thread_interrupted
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Thread_interrupted(Thread* t, object, uintptr_t* arguments)
 {
-  int64_t peer; memcpy(&peer, arguments, 8);
+  int64_t peer;
+  memcpy(&peer, arguments, 8);
 
-  return threadIsInterrupted
-    (t, reinterpret_cast<Thread*>(peer)->javaThread, true);
+  return threadIsInterrupted(
+      t, reinterpret_cast<Thread*>(peer)->javaThread, true);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Thread_getStackTrace
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Thread_getStackTrace(Thread* t,
+                                         object,
+                                         uintptr_t* arguments)
 {
-  int64_t peer; memcpy(&peer, arguments, 8);
+  int64_t peer;
+  memcpy(&peer, arguments, 8);
 
   if (reinterpret_cast<Thread*>(peer) == t) {
     return reinterpret_cast<int64_t>(makeTrace(t));
   } else {
-    return reinterpret_cast<int64_t>
-      (t->m->processor->getStackTrace(t, reinterpret_cast<Thread*>(peer)));
+    return reinterpret_cast<int64_t>(
+        t->m->processor->getStackTrace(t, reinterpret_cast<Thread*>(peer)));
   }
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Thread_activeCount
-(Thread* t, object, uintptr_t*)
+    Avian_java_lang_Thread_activeCount(Thread* t, object, uintptr_t*)
 {
   return t->m->liveCount;
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Thread_enumerate
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Thread_enumerate(Thread* t, object, uintptr_t* arguments)
 {
   GcArray* array = cast<GcArray>(t, reinterpret_cast<object>(*arguments));
 
@@ -731,15 +731,13 @@ Avian_java_lang_Thread_enumerate
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_java_lang_Thread_yield
-(Thread* t, object, uintptr_t*)
+    Avian_java_lang_Thread_yield(Thread* t, object, uintptr_t*)
 {
   t->m->system->yield();
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_Atomic_getOffset
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Atomic_getOffset(Thread* t, object, uintptr_t* arguments)
 {
   return cast<GcJfield>(t, reinterpret_cast<object>(arguments[0]))
       ->vmField()
@@ -747,8 +745,9 @@ Avian_avian_Atomic_getOffset
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_objectFieldOffset
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_objectFieldOffset(Thread* t,
+                                            object,
+                                            uintptr_t* arguments)
 {
   return cast<GcJfield>(t, reinterpret_cast<object>(arguments[1]))
       ->vmField()
@@ -756,16 +755,18 @@ Avian_sun_misc_Unsafe_objectFieldOffset
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_Atomic_compareAndSwapObject
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Atomic_compareAndSwapObject(Thread* t,
+                                            object,
+                                            uintptr_t* arguments)
 {
   object target = reinterpret_cast<object>(arguments[0]);
-  int64_t offset; memcpy(&offset, arguments + 1, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 1, 8);
   uintptr_t expect = arguments[3];
   uintptr_t update = arguments[4];
 
-  bool success = atomicCompareAndSwap
-    (&fieldAtOffset<uintptr_t>(target, offset), expect, update);
+  bool success = atomicCompareAndSwap(
+      &fieldAtOffset<uintptr_t>(target, offset), expect, update);
 
   if (success) {
     mark(t, target, offset);
@@ -775,8 +776,9 @@ Avian_avian_Atomic_compareAndSwapObject
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_Classes_isAssignableFrom
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Classes_isAssignableFrom(Thread* t,
+                                         object,
+                                         uintptr_t* arguments)
 {
   GcClass* this_ = cast<GcClass>(t, reinterpret_cast<object>(arguments[0]));
   GcClass* that = cast<GcClass>(t, reinterpret_cast<object>(arguments[1]));
@@ -789,16 +791,14 @@ Avian_avian_Classes_isAssignableFrom
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_Classes_getVMClass
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Classes_getVMClass(Thread* t, object, uintptr_t* arguments)
 {
-  return reinterpret_cast<int64_t>
-    (objectClass(t, reinterpret_cast<object>(arguments[0])));
+  return reinterpret_cast<int64_t>(
+      objectClass(t, reinterpret_cast<object>(arguments[0])));
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_avian_Classes_makeMethod
-(Thread* t, object, uintptr_t* arguments)
+    Avian_avian_Classes_makeMethod(Thread* t, object, uintptr_t* arguments)
 {
   GcMethod* method = cast<GcMethod>(
       t,
diff --git a/src/classpath-openjdk.cpp b/src/classpath-openjdk.cpp
index 8d0bfa6b78..8e7ee8db14 100644
--- a/src/classpath-openjdk.cpp
+++ b/src/classpath-openjdk.cpp
@@ -15,72 +15,72 @@
 
 #ifdef PLATFORM_WINDOWS
 
-#  include <windows.h>
-#  include <io.h>
-#  include <direct.h>
-#  include <share.h>
-#  include <errno.h>
-#  include <fcntl.h>
-#  include <sys/stat.h>
-#  include <sys/types.h>
+#include <windows.h>
+#include <io.h>
+#include <direct.h>
+#include <share.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
 
-#  undef interface
+#undef interface
 
-#  define CLOSE _close
-#  define READ _read
-#  define WRITE _write
-#  define FSTAT _fstat
-#  define STAT _stat
-#  define LSEEK _lseek
+#define CLOSE _close
+#define READ _read
+#define WRITE _write
+#define FSTAT _fstat
+#define STAT _stat
+#define LSEEK _lseek
 
-#  define S_ISSOCK(x) false
+#define S_ISSOCK(x) false
 
-#  ifdef _MSC_VER
-#    define S_ISREG(x) ((x) | _S_IFREG)
-#    define S_ISDIR(x) ((x) | _S_IFDIR)
-#    define S_IRUSR _S_IREAD
-#    define S_IWUSR _S_IWRITE
-#  else
-#    define OPEN _open
-#  endif
+#ifdef _MSC_VER
+#define S_ISREG(x) ((x) | _S_IFREG)
+#define S_ISDIR(x) ((x) | _S_IFDIR)
+#define S_IRUSR _S_IREAD
+#define S_IWUSR _S_IWRITE
+#else
+#define OPEN _open
+#endif
 
-#  define O_RDONLY _O_RDONLY
+#define O_RDONLY _O_RDONLY
 
-#  if (defined AVIAN_OPENJDK_SRC) \
-  || ((defined __x86_64__) && (defined __MINGW32__))
-#    define EXPORT(x) x
-#  else
-#    define EXPORT(x) _##x
-#  endif
+#if (defined AVIAN_OPENJDK_SRC) \
+    || ((defined __x86_64__) && (defined __MINGW32__))
+#define EXPORT(x) x
+#else
+#define EXPORT(x) _##x
+#endif
 
 typedef int socklen_t;
 
-#  define RTLD_DEFAULT 0
+#define RTLD_DEFAULT 0
 
-#else // not PLATFORM_WINDOWS
+#else  // not PLATFORM_WINDOWS
 
-#  include <unistd.h>
-#  include <limits.h>
-#  include <sys/types.h>
-#  include <sys/stat.h>
-#  include <sys/socket.h>
-#  include <sys/ioctl.h>
-#  include <fcntl.h>
-#  include <errno.h>
-#  include <sched.h>
-#  include <dlfcn.h>
+#include <unistd.h>
+#include <limits.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sched.h>
+#include <dlfcn.h>
 
-#  define OPEN open
-#  define CLOSE close
-#  define READ read
-#  define WRITE write
-#  define STAT stat
-#  define FSTAT fstat
-#  define LSEEK lseek
+#define OPEN open
+#define CLOSE close
+#define READ read
+#define WRITE write
+#define STAT stat
+#define FSTAT fstat
+#define LSEEK lseek
 
-#  define EXPORT(x) x
+#define EXPORT(x) x
 
-#endif // not PLATFORM_WINDOWS
+#endif  // not PLATFORM_WINDOWS
 
 #define JVM_EEXIST -100
 
@@ -89,14 +89,13 @@ using namespace vm;
 namespace {
 
 #ifdef _MSC_VER
-inline int 
-OPEN(string_t path, int mask, int mode)
+inline int OPEN(string_t path, int mask, int mode)
 {
-  int fd; 
+  int fd;
   if (_wsopen_s(&fd, path, mask, _SH_DENYNO, mode) == 0) {
-    return fd; 
+    return fd;
   } else {
-    return -1; 
+    return -1;
   }
 }
 #endif
@@ -156,130 +155,78 @@ struct JmmInterface {
   void* reserved1;
   void* reserved2;
 
-  jint
-  (JNICALL *GetVersion)
-    (JNIEnv*);
+  jint(JNICALL* GetVersion)(JNIEnv*);
 
-  jint
-  (JNICALL *GetOptionalSupport)
-    (JNIEnv*, jmmOptionalSupport*);
+  jint(JNICALL* GetOptionalSupport)(JNIEnv*, jmmOptionalSupport*);
 
-  jobject
-  (JNICALL *GetInputArguments)
-    (JNIEnv*);
+  jobject(JNICALL* GetInputArguments)(JNIEnv*);
 
-  jint
-  (JNICALL *GetThreadInfo)
-    (JNIEnv*, jlongArray, jint, jobjectArray);
+  jint(JNICALL* GetThreadInfo)(JNIEnv*, jlongArray, jint, jobjectArray);
 
-  jobjectArray
-  (JNICALL *GetInputArgumentArray)
-    (JNIEnv*);
+  jobjectArray(JNICALL* GetInputArgumentArray)(JNIEnv*);
 
-  jobjectArray
-  (JNICALL *GetMemoryPools)
-    (JNIEnv*, jobject);
+  jobjectArray(JNICALL* GetMemoryPools)(JNIEnv*, jobject);
 
-  jobjectArray
-  (JNICALL *GetMemoryManagers)
-    (JNIEnv*, jobject);
+  jobjectArray(JNICALL* GetMemoryManagers)(JNIEnv*, jobject);
 
-  jobject
-  (JNICALL *GetMemoryPoolUsage)
-    (JNIEnv*, jobject);
+  jobject(JNICALL* GetMemoryPoolUsage)(JNIEnv*, jobject);
 
-  jobject
-  (JNICALL *GetPeakMemoryPoolUsage)
-    (JNIEnv*, jobject);
+  jobject(JNICALL* GetPeakMemoryPoolUsage)(JNIEnv*, jobject);
 
   void* reserved4;
 
-  jobject
-  (JNICALL *GetMemoryUsage)
-    (JNIEnv*, jboolean);
+  jobject(JNICALL* GetMemoryUsage)(JNIEnv*, jboolean);
 
-  jlong
-  (JNICALL *GetLongAttribute)
-    (JNIEnv*, jobject, jmmLongAttribute);
+  jlong(JNICALL* GetLongAttribute)(JNIEnv*, jobject, jmmLongAttribute);
 
-  jboolean (JNICALL *GetBoolAttribute)
-    (JNIEnv*, jmmBoolAttribute);
+  jboolean(JNICALL* GetBoolAttribute)(JNIEnv*, jmmBoolAttribute);
 
-  jboolean
-  (JNICALL *SetBoolAttribute)
-    (JNIEnv*, jmmBoolAttribute, jboolean);
+  jboolean(JNICALL* SetBoolAttribute)(JNIEnv*, jmmBoolAttribute, jboolean);
 
-  jint
-  (JNICALL *GetLongAttributes)
-    (JNIEnv*, jobject, jmmLongAttribute*, jint, jlong*);
+  jint(JNICALL* GetLongAttributes)(JNIEnv*,
+                                   jobject,
+                                   jmmLongAttribute*,
+                                   jint,
+                                   jlong*);
 
-  jobjectArray
-  (JNICALL *FindCircularBlockedThreads)
-    (JNIEnv*);
+  jobjectArray(JNICALL* FindCircularBlockedThreads)(JNIEnv*);
 
-  jlong
-  (JNICALL *GetThreadCpuTime)
-  (JNIEnv*, jlong);
+  jlong(JNICALL* GetThreadCpuTime)(JNIEnv*, jlong);
 
-  jobjectArray
-  (JNICALL *GetVMGlobalNames)
-    (JNIEnv*);
+  jobjectArray(JNICALL* GetVMGlobalNames)(JNIEnv*);
 
-  jint
-  (JNICALL *GetVMGlobals)
-    (JNIEnv*, jobjectArray, jmmVMGlobal*, jint);
+  jint(JNICALL* GetVMGlobals)(JNIEnv*, jobjectArray, jmmVMGlobal*, jint);
 
-  jint
-  (JNICALL *GetInternalThreadTimes)
-    (JNIEnv*, jobjectArray, jlongArray);
+  jint(JNICALL* GetInternalThreadTimes)(JNIEnv*, jobjectArray, jlongArray);
 
-  jboolean
-  (JNICALL *ResetStatistic)
-    (JNIEnv*, jvalue, jmmStatisticType);
+  jboolean(JNICALL* ResetStatistic)(JNIEnv*, jvalue, jmmStatisticType);
 
-  void
-  (JNICALL *SetPoolSensor)
-  (JNIEnv*, jobject, jmmThresholdType, jobject);
+  void(JNICALL* SetPoolSensor)(JNIEnv*, jobject, jmmThresholdType, jobject);
 
-  jlong
-  (JNICALL *SetPoolThreshold)
-    (JNIEnv*, jobject, jmmThresholdType, jlong);
+  jlong(JNICALL* SetPoolThreshold)(JNIEnv*, jobject, jmmThresholdType, jlong);
 
-  jobject
-  (JNICALL *GetPoolCollectionUsage)
-  (JNIEnv*, jobject);
+  jobject(JNICALL* GetPoolCollectionUsage)(JNIEnv*, jobject);
 
-  jint
-  (JNICALL *GetGCExtAttributeInfo)
-    (JNIEnv*, jobject, jmmExtAttributeInfo*, jint);
+  jint(JNICALL* GetGCExtAttributeInfo)(JNIEnv*,
+                                       jobject,
+                                       jmmExtAttributeInfo*,
+                                       jint);
 
-  void
-  (JNICALL *GetLastGCStat)
-  (JNIEnv*, jobject, jmmGCStat*);
+  void(JNICALL* GetLastGCStat)(JNIEnv*, jobject, jmmGCStat*);
 
-  jlong
-  (JNICALL *GetThreadCpuTimeWithKind)
-    (JNIEnv*, jlong, jboolean);
+  jlong(JNICALL* GetThreadCpuTimeWithKind)(JNIEnv*, jlong, jboolean);
 
   void* reserved5;
 
-  jint
-  (JNICALL *DumpHeap0)
-    (JNIEnv*, jstring, jboolean);
+  jint(JNICALL* DumpHeap0)(JNIEnv*, jstring, jboolean);
 
-  jobjectArray
-  (JNICALL *FindDeadlocks)
-    (JNIEnv*, jboolean);
+  jobjectArray(JNICALL* FindDeadlocks)(JNIEnv*, jboolean);
 
-  void
-  (JNICALL *SetVMGlobal)
-  (JNIEnv*, jstring, jvalue );
+  void(JNICALL* SetVMGlobal)(JNIEnv*, jstring, jvalue);
 
   void* reserved6;
 
-  jobjectArray
-  (JNICALL *DumpThreads)
-    (JNIEnv*, jlongArray, jboolean, jboolean);
+  jobjectArray(JNICALL* DumpThreads)(JNIEnv*, jlongArray, jboolean, jboolean);
 };
 
 const unsigned InterfaceVersion = 4;
@@ -350,27 +297,30 @@ object makeJconstructor(Thread* t, GcMethod* vmMethod, int index = -1);
 object makeJfield(Thread* t, GcField* vmField, int index = -1);
 
 #ifdef AVIAN_OPENJDK_SRC
-void
-interceptFileOperations(Thread*, bool);
+void interceptFileOperations(Thread*, bool);
 #endif
 
 class MyClasspath : public Classpath {
  public:
-  MyClasspath(System* s, Allocator* allocator, const char* javaHome,
-              const char* embedPrefix):
-    allocator(allocator), ranNetOnLoad(0), ranManagementOnLoad(0)
+  MyClasspath(System* s,
+              Allocator* allocator,
+              const char* javaHome,
+              const char* embedPrefix)
+      : allocator(allocator), ranNetOnLoad(0), ranManagementOnLoad(0)
   {
     class StringBuilder {
      public:
-      StringBuilder(System* s, Allocator* allocator):
-        s(s),
-        allocator(allocator),
-        bufferSize(1024),
-        buffer(static_cast<char*>(allocator->allocate(bufferSize))),
-        offset(0)
-      { }
+      StringBuilder(System* s, Allocator* allocator)
+          : s(s),
+            allocator(allocator),
+            bufferSize(1024),
+            buffer(static_cast<char*>(allocator->allocate(bufferSize))),
+            offset(0)
+      {
+      }
 
-      void ensure(unsigned capacity) {
+      void ensure(unsigned capacity)
+      {
         if (capacity > bufferSize) {
           unsigned size = max(bufferSize * 2, capacity);
           char* b = static_cast<char*>(allocator->allocate(size));
@@ -380,28 +330,30 @@ class MyClasspath : public Classpath {
           }
 
           allocator->free(buffer, bufferSize);
-          
+
           buffer = b;
           bufferSize = size;
         }
       }
 
-      void append(const char* append) {
+      void append(const char* append)
+      {
         unsigned length = strlen(append);
         ensure(offset + length + 1);
-  
+
         strncpy(buffer + offset, append, length + 1);
-        
+
         offset += length;
       }
 
-      void append(char c) {
+      void append(char c)
+      {
         ensure(2);
-        
+
         buffer[offset] = c;
         buffer[offset + 1] = 0;
 
-        ++ offset;
+        ++offset;
       }
 
       System* s;
@@ -437,18 +389,18 @@ class MyClasspath : public Classpath {
     unsigned libraryPathOffset = sb.offset;
     sb.append(javaHome);
 #ifdef PLATFORM_WINDOWS
-#  define LIB_DIR "/bin"
+#define LIB_DIR "/bin"
 #elif defined __APPLE__
-#  define LIB_DIR "/lib"
+#define LIB_DIR "/lib"
 #elif defined ARCH_x86_64
-#  define LIB_DIR "/lib/amd64"
+#define LIB_DIR "/lib/amd64"
 #elif defined ARCH_arm
-#  define LIB_DIR "/lib/arm"
+#define LIB_DIR "/lib/arm"
 #else
-    // todo: handle other architectures
-#  define LIB_DIR "/lib/i386"
+// todo: handle other architectures
+#define LIB_DIR "/lib/i386"
 #endif
-    
+
 #ifdef PLATFORM_WINDOWS
     sb.append(LIB_DIR);
 #else
@@ -517,8 +469,8 @@ class MyClasspath : public Classpath {
           object s = makeNew(t, type(t, GcString::Type));
           PROTECT(t, s);
 
-          t->m->processor->invoke
-            (t, constructor, s, array, offset, length, utf8);
+          t->m->processor->invoke(
+              t, constructor, s, array, offset, length, utf8);
 
           return cast<GcString>(t, s);
         }
@@ -617,36 +569,34 @@ class MyClasspath : public Classpath {
             ->body()[jfield->slot()]);
   }
 
-  virtual void
-  clearInterrupted(Thread* t)
+  virtual void clearInterrupted(Thread* t)
   {
     vm::clearInterrupted(t);
   }
 
-  virtual void
-  runThread(Thread* t)
+  virtual void runThread(Thread* t)
   {
     // force monitor creation so we don't get an OutOfMemory error
     // later when we try to acquire it:
     objectMonitor(t, t->javaThread, true);
 
     THREAD_RESOURCE0(t, {
-        vm::acquire(t, t->javaThread);
-        t->flags &= ~Thread::ActiveFlag;
-        vm::notifyAll(t, t->javaThread);
-        vm::release(t, t->javaThread);
+      vm::acquire(t, t->javaThread);
+      t->flags &= ~Thread::ActiveFlag;
+      vm::notifyAll(t, t->javaThread);
+      vm::release(t, t->javaThread);
 
-        GcThrowable* e = t->exception;
-        PROTECT(t, e);
+      GcThrowable* e = t->exception;
+      PROTECT(t, e);
 
-        t->exception = 0;
+      t->exception = 0;
 
-        t->m->processor->invoke(t,
-                                cast<GcMethod>(t, roots(t)->threadTerminated()),
-                                t->javaThread->group(),
-                                t->javaThread);
+      t->m->processor->invoke(t,
+                              cast<GcMethod>(t, roots(t)->threadTerminated()),
+                              t->javaThread->group(),
+                              t->javaThread);
 
-        t->exception = e;
+      t->exception = e;
     });
 
     GcMethod* method = resolveMethod(
@@ -671,16 +621,14 @@ class MyClasspath : public Classpath {
     vm::resolveNative(t, method);
   }
 
-  virtual void
-  interceptMethods(Thread* t UNUSED)
+  virtual void interceptMethods(Thread* t UNUSED)
   {
 #ifdef AVIAN_OPENJDK_SRC
     interceptFileOperations(t, false);
 #endif
   }
 
-  virtual void
-  preBoot(Thread*)
+  virtual void preBoot(Thread*)
   {
     // ignore
   }
@@ -690,8 +638,7 @@ class MyClasspath : public Classpath {
     return true;
   }
 
-  virtual void
-  boot(Thread* t)
+  virtual void boot(Thread* t)
   {
     globalMachine = t->m;
 
@@ -708,10 +655,10 @@ class MyClasspath : public Classpath {
 
 #ifdef AVIAN_OPENJDK_SRC
     interceptFileOperations(t, true);
-#else // not AVIAN_OPENJDK_SRC
+#else   // not AVIAN_OPENJDK_SRC
     expect(t, loadLibrary(t, libraryPath, "verify", true, true));
     expect(t, loadLibrary(t, libraryPath, "java", true, true));
-#endif // not AVIAN_OPENJDK_SRC
+#endif  // not AVIAN_OPENJDK_SRC
 
     {
       GcField* assertionLock = resolveField(t,
@@ -733,7 +680,7 @@ class MyClasspath : public Classpath {
                                      GcNoClassDefFoundError::Type);
 
       PROTECT(t, class_);
-      
+
       object instance = makeNew(t, class_);
 
       PROTECT(t, instance);
@@ -800,14 +747,12 @@ class MyClasspath : public Classpath {
     t->javaThread->setContextClassLoader(t, roots(t)->appLoader());
   }
 
-  virtual const char*
-  bootClasspath()
+  virtual const char* bootClasspath()
   {
     return classpath;
   }
 
-  virtual object
-  makeDirectByteBuffer(Thread* t, void* p, jlong capacity)
+  virtual object makeDirectByteBuffer(Thread* t, void* p, jlong capacity)
   {
     GcClass* c
         = resolveClass(t, roots(t)->bootLoader(), "java/nio/DirectByteBuffer");
@@ -818,15 +763,16 @@ class MyClasspath : public Classpath {
 
     GcMethod* constructor = resolveMethod(t, c, "<init>", "(JI)V");
 
-    t->m->processor->invoke
-      (t, constructor, instance, reinterpret_cast<int64_t>(p),
-       static_cast<int32_t>(capacity));
+    t->m->processor->invoke(t,
+                            constructor,
+                            instance,
+                            reinterpret_cast<int64_t>(p),
+                            static_cast<int32_t>(capacity));
 
     return instance;
   }
 
-  virtual void*
-  getDirectBufferAddress(Thread* t, object b)
+  virtual void* getDirectBufferAddress(Thread* t, object b)
   {
     PROTECT(t, b);
 
@@ -835,8 +781,7 @@ class MyClasspath : public Classpath {
     return reinterpret_cast<void*>(fieldAtOffset<int64_t>(b, field->offset()));
   }
 
-  virtual int64_t
-  getDirectBufferCapacity(Thread* t, object b)
+  virtual int64_t getDirectBufferCapacity(Thread* t, object b)
   {
     PROTECT(t, b);
 
@@ -897,8 +842,7 @@ class MyClasspath : public Classpath {
                : caller->class_()->loader();
   }
 
-  virtual void
-  shutDown(Thread* t)
+  virtual void shutDown(Thread* t)
   {
     GcClass* c
         = resolveClass(t, roots(t)->bootLoader(), "java/lang/Shutdown", false);
@@ -912,9 +856,8 @@ class MyClasspath : public Classpath {
     }
   }
 
-  virtual void
-  dispose()
-  { 
+  virtual void dispose()
+  {
     allocator->free(buffer, bufferSize);
     allocator->free(this, sizeof(*this));
   }
@@ -953,19 +896,18 @@ struct JVM_ExceptionTableEntryType {
 
 struct jvm_version_info {
   unsigned jvm_version;
-  unsigned update_version: 8;
-  unsigned special_update_version: 8;
-  unsigned reserved1: 16;
+  unsigned update_version : 8;
+  unsigned special_update_version : 8;
+  unsigned reserved1 : 16;
   unsigned reserved2;
-  unsigned is_attach_supported: 1;
-  unsigned is_kernel_jvm: 1;
-  unsigned: 30;
-  unsigned: 32;
-  unsigned: 32;
+  unsigned is_attach_supported : 1;
+  unsigned is_kernel_jvm : 1;
+  unsigned : 30;
+  unsigned : 32;
+  unsigned : 32;
 };
 
-bool
-pathEqual(const char* a, const char* b, unsigned length)
+bool pathEqual(const char* a, const char* b, unsigned length)
 {
 #ifdef PLATFORM_WINDOWS
   return strncasecmp(a, b, length) == 0;
@@ -976,10 +918,12 @@ pathEqual(const char* a, const char* b, unsigned length)
 
 class EmbeddedFile {
  public:
-  EmbeddedFile(MyClasspath* cp, const char* path, unsigned pathLength) {
+  EmbeddedFile(MyClasspath* cp, const char* path, unsigned pathLength)
+  {
     if (pathEqual(cp->embedPrefix, path, cp->embedPrefixLength)) {
       const char* p = path + cp->embedPrefixLength;
-      while (*p == '/') ++ p;
+      while (*p == '/')
+        ++p;
 
       this->jar = p;
 
@@ -990,17 +934,19 @@ class EmbeddedFile {
         return;
       }
 
-      while (*p and *p != '/') ++p;
-    
+      while (*p and *p != '/')
+        ++p;
+
       this->jarLength = p - this->jar;
 
-      while (*p == '/') ++p;
+      while (*p == '/')
+        ++p;
 
       this->path = p;
       this->pathLength = pathLength - (p - path);
     } else {
       this->jar = 0;
-      this->jarLength =0;
+      this->jarLength = 0;
       this->path = 0;
       this->pathLength = 0;
     }
@@ -1014,8 +960,7 @@ class EmbeddedFile {
 
 #ifdef AVIAN_OPENJDK_SRC
 int64_t JNICALL
-getFileAttributes
-(Thread* t, object method, uintptr_t* arguments)
+    getFileAttributes(Thread* t, object method, uintptr_t* arguments)
 {
   const unsigned Exists = 1;
   const unsigned Regular = 2;
@@ -1045,30 +990,36 @@ getFileAttributes
       unsigned length;
       System::FileType type = finder->stat(ef.path, &length, true);
       switch (type) {
-      case System::TypeUnknown: return Exists;
-      case System::TypeDoesNotExist: return 0;
-      case System::TypeFile: return Exists | Regular;
-      case System::TypeDirectory: return Exists | Directory;
-      default: abort(t);
+      case System::TypeUnknown:
+        return Exists;
+      case System::TypeDoesNotExist:
+        return 0;
+      case System::TypeFile:
+        return Exists | Regular;
+      case System::TypeDirectory:
+        return Exists | Directory;
+      default:
+        abort(t);
       }
     } else {
       return 0;
     }
   } else {
-    return intValue
-      (t, t->m->processor->invoke
-       (t, nativeInterceptOriginal
-        (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-        reinterpret_cast<object>(arguments[0]), file));
+    return intValue(
+        t,
+        t->m->processor->invoke(
+            t,
+            nativeInterceptOriginal(
+                t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+            reinterpret_cast<object>(arguments[0]),
+            file));
   }
 }
 
-int64_t JNICALL
-checkFileAccess
-(Thread* t, object method, uintptr_t* arguments)
+int64_t JNICALL checkFileAccess(Thread* t, object method, uintptr_t* arguments)
 {
   const unsigned Read = 4;
-  
+
   MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
 
   object file = reinterpret_cast<object>(arguments[1]);
@@ -1094,27 +1045,33 @@ checkFileAccess
       unsigned length;
       System::FileType type = finder->stat(ef.path, &length, true);
       switch (type) {
-      case System::TypeDoesNotExist: return false;
+      case System::TypeDoesNotExist:
+        return false;
       case System::TypeUnknown:
       case System::TypeFile:
-      case System::TypeDirectory: return mask == Read;
-      default: abort(t);
+      case System::TypeDirectory:
+        return mask == Read;
+      default:
+        abort(t);
       }
     } else {
       return 0;
     }
   } else {
-    return intValue
-      (t, t->m->processor->invoke
-       (t, nativeInterceptOriginal
-        (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-        reinterpret_cast<object>(arguments[0]), file, mask)) != 0;
+    return intValue(t,
+                    t->m->processor->invoke(
+                        t,
+                        nativeInterceptOriginal(
+                            t,
+                            methodRuntimeDataNative(
+                                t, getMethodRuntimeData(t, method))),
+                        reinterpret_cast<object>(arguments[0]),
+                        file,
+                        mask)) != 0;
   }
 }
 
-int64_t JNICALL
-getFileLength
-(Thread* t, object method, uintptr_t* arguments)
+int64_t JNICALL getFileLength(Thread* t, object method, uintptr_t* arguments)
 {
   MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
 
@@ -1144,16 +1101,18 @@ getFileLength
 
     return 0;
   } else {
-    return longValue
-      (t, t->m->processor->invoke
-       (t, nativeInterceptOriginal
-        (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-        reinterpret_cast<object>(arguments[0]), file));
+    return longValue(
+        t,
+        t->m->processor->invoke(
+            t,
+            nativeInterceptOriginal(
+                t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+            reinterpret_cast<object>(arguments[0]),
+            file));
   }
 }
 
-void JNICALL
-openFile(Thread* t, object method, uintptr_t* arguments)
+void JNICALL openFile(Thread* t, object method, uintptr_t* arguments)
 {
   object this_ = reinterpret_cast<object>(arguments[0]);
   object path = reinterpret_cast<object>(arguments[1]);
@@ -1208,28 +1167,28 @@ openFile(Thread* t, object method, uintptr_t* arguments)
         ArrayBody + (index * BytesPerWord),
         region);
 
-    fieldAtOffset<int32_t>
-      (fieldAtOffset<object>
-       (this_, cp->fileInputStreamFdField), cp->fileDescriptorFdField)
-      = index + VirtualFileBase;
+    fieldAtOffset<int32_t>(
+        fieldAtOffset<object>(this_, cp->fileInputStreamFdField),
+        cp->fileDescriptorFdField) = index + VirtualFileBase;
   } else {
-    t->m->processor->invoke
-      (t, nativeInterceptOriginal
-       (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-       this_, path);
+    t->m->processor->invoke(
+        t,
+        nativeInterceptOriginal(
+            t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+        this_,
+        path);
   }
 }
 
-int64_t JNICALL
-readByteFromFile(Thread* t, object method, uintptr_t* arguments)
+int64_t JNICALL readByteFromFile(Thread* t, object method, uintptr_t* arguments)
 {
   object this_ = reinterpret_cast<object>(arguments[0]);
 
   MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
 
-  int fd = fieldAtOffset<int32_t>
-    (fieldAtOffset<object>
-     (this_, cp->fileInputStreamFdField), cp->fileDescriptorFdField);
+  int fd = fieldAtOffset<int32_t>(
+      fieldAtOffset<object>(this_, cp->fileInputStreamFdField),
+      cp->fileDescriptorFdField);
 
   if (fd >= VirtualFileBase) {
     ACQUIRE(t, t->m->referenceLock);
@@ -1238,8 +1197,7 @@ readByteFromFile(Thread* t, object method, uintptr_t* arguments)
         = arrayBody(t, roots(t)->virtualFiles(), fd - VirtualFileBase);
 
     if (region) {
-      System::Region* r = static_cast<System::Region*>
-        (regionRegion(t, region));
+      System::Region* r = static_cast<System::Region*>(regionRegion(t, region));
 
       if (r->length() > regionPosition(t, region)) {
         return r->start()[regionPosition(t, region)++];
@@ -1250,16 +1208,18 @@ readByteFromFile(Thread* t, object method, uintptr_t* arguments)
       throwNew(t, GcIoException::Type);
     }
   } else {
-    return intValue
-      (t, t->m->processor->invoke
-       (t, nativeInterceptOriginal
-        (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-        this_));
+    return intValue(
+        t,
+        t->m->processor->invoke(
+            t,
+            nativeInterceptOriginal(
+                t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+            this_));
   }
 }
 
 int64_t JNICALL
-readBytesFromFile(Thread* t, object method, uintptr_t* arguments)
+    readBytesFromFile(Thread* t, object method, uintptr_t* arguments)
 {
   object this_ = reinterpret_cast<object>(arguments[0]);
   object dst = reinterpret_cast<object>(arguments[1]);
@@ -1268,9 +1228,9 @@ readBytesFromFile(Thread* t, object method, uintptr_t* arguments)
 
   MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
 
-  int fd = fieldAtOffset<int32_t>
-    (fieldAtOffset<object>
-     (this_, cp->fileInputStreamFdField), cp->fileDescriptorFdField);
+  int fd = fieldAtOffset<int32_t>(
+      fieldAtOffset<object>(this_, cp->fileInputStreamFdField),
+      cp->fileDescriptorFdField);
 
   if (fd >= VirtualFileBase) {
     PROTECT(t, dst);
@@ -1281,8 +1241,7 @@ readBytesFromFile(Thread* t, object method, uintptr_t* arguments)
         = arrayBody(t, roots(t)->virtualFiles(), fd - VirtualFileBase);
 
     if (region) {
-      System::Region* r = static_cast<System::Region*>
-        (regionRegion(t, region));
+      System::Region* r = static_cast<System::Region*>(regionRegion(t, region));
 
       int available = r->length() - regionPosition(t, region);
       if (available == 0) {
@@ -1304,25 +1263,30 @@ readBytesFromFile(Thread* t, object method, uintptr_t* arguments)
       throwNew(t, GcIoException::Type);
     }
   } else {
-    return intValue
-      (t, t->m->processor->invoke
-       (t, nativeInterceptOriginal
-        (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-        this_, dst, offset, length));
+    return intValue(
+        t,
+        t->m->processor->invoke(
+            t,
+            nativeInterceptOriginal(
+                t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+            this_,
+            dst,
+            offset,
+            length));
   }
 }
 
-int64_t JNICALL
-skipBytesInFile(Thread* t, object method, uintptr_t* arguments)
+int64_t JNICALL skipBytesInFile(Thread* t, object method, uintptr_t* arguments)
 {
   object this_ = reinterpret_cast<object>(arguments[0]);
-  int64_t count; memcpy(&count, arguments + 1, 8);
+  int64_t count;
+  memcpy(&count, arguments + 1, 8);
 
   MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
 
-  int fd = fieldAtOffset<int32_t>
-    (fieldAtOffset<object>
-     (this_, cp->fileInputStreamFdField), cp->fileDescriptorFdField);
+  int fd = fieldAtOffset<int32_t>(
+      fieldAtOffset<object>(this_, cp->fileInputStreamFdField),
+      cp->fileDescriptorFdField);
 
   if (fd >= VirtualFileBase) {
     ACQUIRE(t, t->m->referenceLock);
@@ -1331,8 +1295,7 @@ skipBytesInFile(Thread* t, object method, uintptr_t* arguments)
         = arrayBody(t, roots(t)->virtualFiles(), fd - VirtualFileBase);
 
     if (region) {
-      System::Region* r = static_cast<System::Region*>
-        (regionRegion(t, region));
+      System::Region* r = static_cast<System::Region*>(regionRegion(t, region));
 
       int available = r->length() - regionPosition(t, region);
       if (count > available) {
@@ -1346,24 +1309,27 @@ skipBytesInFile(Thread* t, object method, uintptr_t* arguments)
       throwNew(t, GcIoException::Type);
     }
   } else {
-    return longValue
-      (t, t->m->processor->invoke
-       (t, nativeInterceptOriginal
-        (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-        this_, count));
+    return longValue(
+        t,
+        t->m->processor->invoke(
+            t,
+            nativeInterceptOriginal(
+                t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+            this_,
+            count));
   }
 }
 
 int64_t JNICALL
-availableBytesInFile(Thread* t, object method, uintptr_t* arguments)
+    availableBytesInFile(Thread* t, object method, uintptr_t* arguments)
 {
   object this_ = reinterpret_cast<object>(arguments[0]);
 
   MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
 
-  int fd = fieldAtOffset<int32_t>
-    (fieldAtOffset<object>
-     (this_, cp->fileInputStreamFdField), cp->fileDescriptorFdField);
+  int fd = fieldAtOffset<int32_t>(
+      fieldAtOffset<object>(this_, cp->fileInputStreamFdField),
+      cp->fileDescriptorFdField);
 
   if (fd >= VirtualFileBase) {
     ACQUIRE(t, t->m->referenceLock);
@@ -1373,30 +1339,30 @@ availableBytesInFile(Thread* t, object method, uintptr_t* arguments)
 
     if (region) {
       return static_cast<System::Region*>(regionRegion(t, region))->length()
-        - regionPosition(t, region);
+             - regionPosition(t, region);
     } else {
       throwNew(t, GcIoException::Type);
     }
   } else {
-    object r = t->m->processor->invoke
-      (t, nativeInterceptOriginal
-       (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-       this_);
+    object r = t->m->processor->invoke(
+        t,
+        nativeInterceptOriginal(
+            t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+        this_);
 
     return r ? intValue(t, r) : 0;
   }
 }
 
-void JNICALL
-closeFile(Thread* t, object method, uintptr_t* arguments)
+void JNICALL closeFile(Thread* t, object method, uintptr_t* arguments)
 {
   object this_ = reinterpret_cast<object>(arguments[0]);
 
   MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
 
-  int fd = fieldAtOffset<int32_t>
-    (fieldAtOffset<object>
-     (this_, cp->fileInputStreamFdField), cp->fileDescriptorFdField);
+  int fd = fieldAtOffset<int32_t>(
+      fieldAtOffset<object>(this_, cp->fileInputStreamFdField),
+      cp->fileDescriptorFdField);
 
   if (fd >= VirtualFileBase) {
     ACQUIRE(t, t->m->referenceLock);
@@ -1410,10 +1376,11 @@ closeFile(Thread* t, object method, uintptr_t* arguments)
 
     set(t, roots(t)->virtualFiles(), ArrayBody + (index * BytesPerWord), 0);
   } else {
-    t->m->processor->invoke
-      (t, nativeInterceptOriginal
-       (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-       this_);
+    t->m->processor->invoke(
+        t,
+        nativeInterceptOriginal(
+            t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+        this_);
   }
 }
 
@@ -1421,17 +1388,18 @@ class ZipFile {
  public:
   class Entry {
    public:
-    Entry(unsigned hash, const uint8_t* start, Entry* next):
-      hash(hash), start(start), next(next), entry(0)
-    { }
+    Entry(unsigned hash, const uint8_t* start, Entry* next)
+        : hash(hash), start(start), next(next), entry(0)
+    {
+    }
 
-    Entry(int64_t entry):
-      hash(0), start(0), next(0), entry(entry)
-    { }
-    
-    Entry():
-      hash(0), start(0), next(0), entry(0)
-    { }
+    Entry(int64_t entry) : hash(0), start(0), next(0), entry(entry)
+    {
+    }
+
+    Entry() : hash(0), start(0), next(0), entry(0)
+    {
+    }
 
     unsigned hash;
     const uint8_t* start;
@@ -1439,20 +1407,21 @@ class ZipFile {
     int64_t entry;
   };
 
-  ZipFile(Thread* t, System::Region* region, unsigned entryCount):
-    region(region),
-    entryCount(entryCount),
-    indexSize(nextPowerOfTwo(entryCount)),
-    index(reinterpret_cast<ZipFile::Entry**>
-          (t->m->heap->allocate(sizeof(ZipFile::Entry*) * indexSize))),
-    file(0)
+  ZipFile(Thread* t, System::Region* region, unsigned entryCount)
+      : region(region),
+        entryCount(entryCount),
+        indexSize(nextPowerOfTwo(entryCount)),
+        index(reinterpret_cast<ZipFile::Entry**>(
+            t->m->heap->allocate(sizeof(ZipFile::Entry*) * indexSize))),
+        file(0)
   {
     memset(index, 0, sizeof(ZipFile::Entry*) * indexSize);
   }
 
-  ZipFile(int64_t file):
-    region(0), entryCount(0), indexSize(0), index(0), file(file)
-  { }
+  ZipFile(int64_t file)
+      : region(0), entryCount(0), indexSize(0), index(0), file(file)
+  {
+  }
 
   System::Region* region;
   unsigned entryCount;
@@ -1462,12 +1431,12 @@ class ZipFile {
   Entry entries[0];
 };
 
-int64_t JNICALL
-openZipFile(Thread* t, object method, uintptr_t* arguments)
+int64_t JNICALL openZipFile(Thread* t, object method, uintptr_t* arguments)
 {
   object path = reinterpret_cast<object>(arguments[0]);
   int mode = arguments[1];
-  int64_t lastModified; memcpy(&lastModified, arguments + 2, 8);
+  int64_t lastModified;
+  memcpy(&lastModified, arguments + 2, 8);
 
   MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
 
@@ -1500,7 +1469,7 @@ openZipFile(Thread* t, object method, uintptr_t* arguments)
 
         while (p < end) {
           if (get4(p) == EntrySignature) {
-            ++ entryCount;
+            ++entryCount;
 
             p = endOfEntry(p);
           } else {
@@ -1513,12 +1482,12 @@ openZipFile(Thread* t, object method, uintptr_t* arguments)
     }
 
   make:
-    ZipFile* file = new
-      (t->m->heap->allocate
-       (sizeof(ZipFile) + (sizeof(ZipFile::Entry) * entryCount)))
-      ZipFile(t, r, entryCount);
+    ZipFile* file = new (t->m->heap->allocate(
+        sizeof(ZipFile) + (sizeof(ZipFile::Entry) * entryCount)))
+        ZipFile(t, r, entryCount);
 
-    { unsigned position = 0;
+    {
+      unsigned position = 0;
       for (const uint8_t* p = end - CentralDirectorySearchStart; p > start;) {
         if (get4(p) == CentralDirectorySignature) {
           p = start + centralDirectoryOffset(p);
@@ -1529,7 +1498,7 @@ openZipFile(Thread* t, object method, uintptr_t* arguments)
               unsigned i = h & (file->indexSize - 1);
 
               file->index[i] = new (file->entries + (position++))
-                ZipFile::Entry(h, p, file->index[i]);
+                  ZipFile::Entry(h, p, file->index[i]);
 
               p = endOfEntry(p);
             } else {
@@ -1537,7 +1506,7 @@ openZipFile(Thread* t, object method, uintptr_t* arguments)
             }
           }
         } else {
-          -- p;
+          --p;
         }
       }
     }
@@ -1545,35 +1514,44 @@ openZipFile(Thread* t, object method, uintptr_t* arguments)
   exit:
     return reinterpret_cast<int64_t>(file);
   } else {
-    return reinterpret_cast<int64_t>
-      (new (t->m->heap->allocate(sizeof(ZipFile))) ZipFile
-       (longValue
-        (t, t->m->processor->invoke
-         (t, nativeInterceptOriginal
-          (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-          0, path, mode, lastModified))));
+    return reinterpret_cast<int64_t>(
+        new (t->m->heap->allocate(sizeof(ZipFile)))
+        ZipFile(longValue(t,
+                          t->m->processor->invoke(
+                              t,
+                              nativeInterceptOriginal(
+                                  t,
+                                  methodRuntimeDataNative(
+                                      t, getMethodRuntimeData(t, method))),
+                              0,
+                              path,
+                              mode,
+                              lastModified))));
   }
 }
 
 int64_t JNICALL
-getZipFileEntryCount(Thread* t, object method, uintptr_t* arguments)
+    getZipFileEntryCount(Thread* t, object method, uintptr_t* arguments)
 {
-  int64_t peer; memcpy(&peer, arguments, 8);
+  int64_t peer;
+  memcpy(&peer, arguments, 8);
 
   ZipFile* file = reinterpret_cast<ZipFile*>(peer);
   if (file->region) {
     return file->entryCount;
   } else {
-    return intValue
-      (t, t->m->processor->invoke
-       (t, nativeInterceptOriginal
-        (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-        0, file->file));
+    return intValue(
+        t,
+        t->m->processor->invoke(
+            t,
+            nativeInterceptOriginal(
+                t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+            0,
+            file->file));
   }
 }
 
-ZipFile::Entry*
-find(ZipFile* file, const char* path, unsigned pathLength)
+ZipFile::Entry* find(ZipFile* file, const char* path, unsigned pathLength)
 {
   unsigned i = hash(path) & (file->indexSize - 1);
   for (ZipFile::Entry* e = file->index[i]; e; e = e->next) {
@@ -1585,17 +1563,18 @@ find(ZipFile* file, const char* path, unsigned pathLength)
   return 0;
 }
 
-int64_t JNICALL
-getZipFileEntry(Thread* t, object method, uintptr_t* arguments)
+int64_t JNICALL getZipFileEntry(Thread* t, object method, uintptr_t* arguments)
 {
-  int64_t peer; memcpy(&peer, arguments, 8);
+  int64_t peer;
+  memcpy(&peer, arguments, 8);
   object path = reinterpret_cast<object>(arguments[2]);
   bool addSlash = arguments[3];
 
   ZipFile* file = reinterpret_cast<ZipFile*>(peer);
   if (file->region) {
     THREAD_RUNTIME_ARRAY(t, char, p, byteArrayLength(t, path) + 2);
-    memcpy(RUNTIME_ARRAY_BODY(p), &byteArrayBody(t, path, 0),
+    memcpy(RUNTIME_ARRAY_BODY(p),
+           &byteArrayBody(t, path, 0),
            byteArrayLength(t, path));
     RUNTIME_ARRAY_BODY(p)[byteArrayLength(t, path)] = 0;
     replace('\\', '/', RUNTIME_ARRAY_BODY(p));
@@ -1604,31 +1583,37 @@ getZipFileEntry(Thread* t, object method, uintptr_t* arguments)
       RUNTIME_ARRAY_BODY(p)[byteArrayLength(t, path) + 1] = 0;
     }
 
-    return reinterpret_cast<int64_t>
-      (find(file, RUNTIME_ARRAY_BODY(p), byteArrayLength(t, path)));
+    return reinterpret_cast<int64_t>(
+        find(file, RUNTIME_ARRAY_BODY(p), byteArrayLength(t, path)));
   } else {
-    int64_t entry = longValue
-      (t, t->m->processor->invoke
-       (t, nativeInterceptOriginal
-        (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-        0, file->file, path, addSlash));
+    int64_t entry = longValue(
+        t,
+        t->m->processor->invoke(
+            t,
+            nativeInterceptOriginal(
+                t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+            0,
+            file->file,
+            path,
+            addSlash));
 
-    return entry ? reinterpret_cast<int64_t>
-      (new (t->m->heap->allocate(sizeof(ZipFile::Entry)))
-       ZipFile::Entry(entry)) : 0;
+    return entry ? reinterpret_cast<int64_t>(new (t->m->heap->allocate(
+                       sizeof(ZipFile::Entry))) ZipFile::Entry(entry))
+                 : 0;
   }
 }
 
 int64_t JNICALL
-getZipFileEntryBytes(Thread* t, object method, uintptr_t* arguments)
+    getZipFileEntryBytes(Thread* t, object method, uintptr_t* arguments)
 {
-  int64_t peer; memcpy(&peer, arguments, 8);
+  int64_t peer;
+  memcpy(&peer, arguments, 8);
   int type = arguments[2];
 
   ZipFile::Entry* entry = reinterpret_cast<ZipFile::Entry*>(peer);
   if (entry->start) {
     switch (type) {
-    case 0: { // name
+    case 0: {  // name
       unsigned nameLength = fileNameLength(entry->start);
       object array = makeByteArray(t, nameLength + 1);
       memcpy(&byteArrayBody(t, array, 0), fileName(entry->start), nameLength);
@@ -1636,123 +1621,151 @@ getZipFileEntryBytes(Thread* t, object method, uintptr_t* arguments)
       return reinterpret_cast<int64_t>(array);
     } break;
 
-    case 1: { // extra
+    case 1: {  // extra
       return 0;
     } break;
 
-    case 2: { // comment
+    case 2: {  // comment
       return 0;
     } break;
 
-    default: abort(t);
+    default:
+      abort(t);
     }
     return compressedSize(entry->start);
   } else {
-    return reinterpret_cast<int64_t>
-      (t->m->processor->invoke
-       (t, nativeInterceptOriginal
-        (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-        0, entry->entry, type));
+    return reinterpret_cast<int64_t>(t->m->processor->invoke(
+        t,
+        nativeInterceptOriginal(
+            t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+        0,
+        entry->entry,
+        type));
   }
 }
 
 int64_t JNICALL
-getNextZipFileEntry(Thread* t, object method, uintptr_t* arguments)
+    getNextZipFileEntry(Thread* t, object method, uintptr_t* arguments)
 {
-  int64_t peer; memcpy(&peer, arguments, 8);
+  int64_t peer;
+  memcpy(&peer, arguments, 8);
   int index = arguments[2];
 
   ZipFile* file = reinterpret_cast<ZipFile*>(peer);
   if (file->region) {
     return reinterpret_cast<int64_t>(file->entries + index);
   } else {
-    int64_t entry = longValue
-      (t, t->m->processor->invoke
-       (t, nativeInterceptOriginal
-        (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-        0, file->file, index));
+    int64_t entry = longValue(
+        t,
+        t->m->processor->invoke(
+            t,
+            nativeInterceptOriginal(
+                t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+            0,
+            file->file,
+            index));
 
-    return entry ? reinterpret_cast<int64_t>
-      (new (t->m->heap->allocate(sizeof(ZipFile::Entry)))
-       ZipFile::Entry(entry)) : 0;
+    return entry ? reinterpret_cast<int64_t>(new (t->m->heap->allocate(
+                       sizeof(ZipFile::Entry))) ZipFile::Entry(entry))
+                 : 0;
   }
 }
 
 int64_t JNICALL
-getZipFileEntryMethod(Thread* t, object method, uintptr_t* arguments)
+    getZipFileEntryMethod(Thread* t, object method, uintptr_t* arguments)
 {
-  int64_t peer; memcpy(&peer, arguments, 8);
+  int64_t peer;
+  memcpy(&peer, arguments, 8);
 
   ZipFile::Entry* entry = reinterpret_cast<ZipFile::Entry*>(peer);
   if (entry->start) {
     return compressionMethod(entry->start);
   } else {
-    return intValue
-      (t, t->m->processor->invoke
-       (t, nativeInterceptOriginal
-        (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-        0, entry->entry));
+    return intValue(
+        t,
+        t->m->processor->invoke(
+            t,
+            nativeInterceptOriginal(
+                t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+            0,
+            entry->entry));
   }
 }
 
-int64_t JNICALL
-getZipFileEntryCompressedSize(Thread* t, object method, uintptr_t* arguments)
+int64_t JNICALL getZipFileEntryCompressedSize(Thread* t,
+                                              object method,
+                                              uintptr_t* arguments)
 {
-  int64_t peer; memcpy(&peer, arguments, 8);
+  int64_t peer;
+  memcpy(&peer, arguments, 8);
 
   ZipFile::Entry* entry = reinterpret_cast<ZipFile::Entry*>(peer);
   if (entry->start) {
     return compressedSize(entry->start);
   } else {
-    return longValue
-      (t, t->m->processor->invoke
-       (t, nativeInterceptOriginal
-        (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-        0, entry->entry));
+    return longValue(
+        t,
+        t->m->processor->invoke(
+            t,
+            nativeInterceptOriginal(
+                t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+            0,
+            entry->entry));
   }
 }
 
-int64_t JNICALL
-getZipFileEntryUncompressedSize(Thread* t, object method, uintptr_t* arguments)
+int64_t JNICALL getZipFileEntryUncompressedSize(Thread* t,
+                                                object method,
+                                                uintptr_t* arguments)
 {
-  int64_t peer; memcpy(&peer, arguments, 8);
+  int64_t peer;
+  memcpy(&peer, arguments, 8);
 
   ZipFile::Entry* entry = reinterpret_cast<ZipFile::Entry*>(peer);
   if (entry->start) {
     return uncompressedSize(entry->start);
   } else {
-    return longValue
-      (t, t->m->processor->invoke
-       (t, nativeInterceptOriginal
-        (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-        0, entry->entry));
+    return longValue(
+        t,
+        t->m->processor->invoke(
+            t,
+            nativeInterceptOriginal(
+                t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+            0,
+            entry->entry));
   }
 }
 
-void JNICALL
-freeZipFileEntry(Thread* t, object method, uintptr_t* arguments)
+void JNICALL freeZipFileEntry(Thread* t, object method, uintptr_t* arguments)
 {
-  int64_t filePeer; memcpy(&filePeer, arguments, 8);
-  int64_t entryPeer; memcpy(&entryPeer, arguments + 2, 8);
+  int64_t filePeer;
+  memcpy(&filePeer, arguments, 8);
+  int64_t entryPeer;
+  memcpy(&entryPeer, arguments + 2, 8);
 
   ZipFile* file = reinterpret_cast<ZipFile*>(filePeer);
   ZipFile::Entry* entry = reinterpret_cast<ZipFile::Entry*>(entryPeer);
   if (file->region == 0) {
-    t->m->processor->invoke
-      (t, nativeInterceptOriginal
-       (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-       0, file->file, entry->entry);
+    t->m->processor->invoke(
+        t,
+        nativeInterceptOriginal(
+            t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+        0,
+        file->file,
+        entry->entry);
   }
 
   t->m->heap->free(entry, sizeof(ZipFile::Entry));
 }
 
-int64_t JNICALL
-readZipFileEntry(Thread* t, object method, uintptr_t* arguments)
+int64_t JNICALL readZipFileEntry(Thread* t, object method, uintptr_t* arguments)
 {
-  int64_t filePeer; memcpy(&filePeer, arguments, 8);
-  int64_t entryPeer; memcpy(&entryPeer, arguments + 2, 8);
-  int64_t position; memcpy(&position, arguments + 4, 8);
+  int64_t filePeer;
+  memcpy(&filePeer, arguments, 8);
+  int64_t entryPeer;
+  memcpy(&entryPeer, arguments + 2, 8);
+  int64_t position;
+  memcpy(&position, arguments + 4, 8);
   object buffer = reinterpret_cast<object>(arguments[6]);
   int offset = arguments[7];
   int length = arguments[8];
@@ -1776,33 +1789,42 @@ readZipFileEntry(Thread* t, object method, uintptr_t* arguments)
 
     return length;
   } else {
-    return intValue
-      (t, t->m->processor->invoke
-       (t, nativeInterceptOriginal
-        (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-        0, file->file, entry->entry, position, buffer, offset, length));
+    return intValue(
+        t,
+        t->m->processor->invoke(
+            t,
+            nativeInterceptOriginal(
+                t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+            0,
+            file->file,
+            entry->entry,
+            position,
+            buffer,
+            offset,
+            length));
   }
 }
 
-int64_t JNICALL
-getZipMessage(Thread* t, object method, uintptr_t* arguments)
+int64_t JNICALL getZipMessage(Thread* t, object method, uintptr_t* arguments)
 {
-  int64_t peer; memcpy(&peer, arguments, 8);
+  int64_t peer;
+  memcpy(&peer, arguments, 8);
 
   ZipFile* file = reinterpret_cast<ZipFile*>(peer);
   if (file->region) {
     return 0;
   } else {
-    return reinterpret_cast<int64_t>
-      (t->m->processor->invoke
-       (t, nativeInterceptOriginal
-        (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-        0, file->file));
+    return reinterpret_cast<int64_t>(t->m->processor->invoke(
+        t,
+        nativeInterceptOriginal(
+            t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+        0,
+        file->file));
   }
 }
 
 int64_t JNICALL
-getJarFileMetaInfEntryNames(Thread* t, object method, uintptr_t* arguments)
+    getJarFileMetaInfEntryNames(Thread* t, object method, uintptr_t* arguments)
 {
   object this_ = reinterpret_cast<object>(arguments[0]);
 
@@ -1827,36 +1849,37 @@ getJarFileMetaInfEntryNames(Thread* t, object method, uintptr_t* arguments)
     // for any other fields in the object.
     object pseudoThis = makeLong(t, file->file);
 
-    return reinterpret_cast<int64_t>
-      (t->m->processor->invoke
-       (t, nativeInterceptOriginal
-        (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+    return reinterpret_cast<int64_t>(t->m->processor->invoke(
+        t,
+        nativeInterceptOriginal(
+            t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
         pseudoThis));
   }
 }
 
-void JNICALL
-closeZipFile(Thread* t, object method, uintptr_t* arguments)
+void JNICALL closeZipFile(Thread* t, object method, uintptr_t* arguments)
 {
-  int64_t peer; memcpy(&peer, arguments, 8);
+  int64_t peer;
+  memcpy(&peer, arguments, 8);
 
   ZipFile* file = reinterpret_cast<ZipFile*>(peer);
   if (file->region) {
     file->region->dispose();
-    t->m->heap->free(file, sizeof(ZipFile)
-                     + (sizeof(ZipFile::Entry) * file->entryCount));
+    t->m->heap->free(
+        file, sizeof(ZipFile) + (sizeof(ZipFile::Entry) * file->entryCount));
   } else {
-    t->m->processor->invoke
-      (t, nativeInterceptOriginal
-       (t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
-       0, file->file);
+    t->m->processor->invoke(
+        t,
+        nativeInterceptOriginal(
+            t, methodRuntimeDataNative(t, getMethodRuntimeData(t, method))),
+        0,
+        file->file);
 
     t->m->heap->free(file, sizeof(ZipFile));
   }
 }
 
-int64_t JNICALL
-getBootstrapResource(Thread* t, object, uintptr_t* arguments)
+int64_t JNICALL getBootstrapResource(Thread* t, object, uintptr_t* arguments)
 {
   object name = reinterpret_cast<object>(arguments[0]);
   PROTECT(t, name);
@@ -1874,8 +1897,7 @@ getBootstrapResource(Thread* t, object, uintptr_t* arguments)
   }
 }
 
-int64_t JNICALL
-getBootstrapResources(Thread* t, object, uintptr_t* arguments)
+int64_t JNICALL getBootstrapResources(Thread* t, object, uintptr_t* arguments)
 {
   object name = reinterpret_cast<object>(arguments[0]);
   PROTECT(t, name);
@@ -1893,14 +1915,11 @@ getBootstrapResources(Thread* t, object, uintptr_t* arguments)
   }
 }
 
-extern "C" AVIAN_EXPORT jint JNICALL
-net_JNI_OnLoad(JavaVM*, void*);
+extern "C" AVIAN_EXPORT jint JNICALL net_JNI_OnLoad(JavaVM*, void*);
 
-extern "C" AVIAN_EXPORT jint JNICALL
-management_JNI_OnLoad(JavaVM*, void*);
+extern "C" AVIAN_EXPORT jint JNICALL management_JNI_OnLoad(JavaVM*, void*);
 
-void JNICALL
-loadLibrary(Thread* t, object, uintptr_t* arguments)
+void JNICALL loadLibrary(Thread* t, object, uintptr_t* arguments)
 {
   Thread::LibraryLoadStack stack(
       t,
@@ -1916,10 +1935,11 @@ loadLibrary(Thread* t, object, uintptr_t* arguments)
     if (strcmp(RUNTIME_ARRAY_BODY(n), "net") == 0) {
       bool ran;
 
-      { ACQUIRE(t, t->m->classLock);
+      {
+        ACQUIRE(t, t->m->classLock);
 
-        local::MyClasspath* c = static_cast<local::MyClasspath*>
-          (t->m->classpath);
+        local::MyClasspath* c
+            = static_cast<local::MyClasspath*>(t->m->classpath);
 
         ran = c->ranNetOnLoad;
         c->ranNetOnLoad = true;
@@ -1930,13 +1950,14 @@ loadLibrary(Thread* t, object, uintptr_t* arguments)
       }
 
       return;
-    } else if (strcmp(RUNTIME_ARRAY_BODY(n), "management") == 0) { 
+    } else if (strcmp(RUNTIME_ARRAY_BODY(n), "management") == 0) {
       bool ran;
 
-      { ACQUIRE(t, t->m->classLock);
+      {
+        ACQUIRE(t, t->m->classLock);
 
-        local::MyClasspath* c = static_cast<local::MyClasspath*>
-          (t->m->classpath);
+        local::MyClasspath* c
+            = static_cast<local::MyClasspath*>(t->m->classpath);
 
         ran = c->ranManagementOnLoad;
         c->ranManagementOnLoad = true;
@@ -1946,21 +1967,21 @@ loadLibrary(Thread* t, object, uintptr_t* arguments)
         management_JNI_OnLoad(t->m, 0);
       }
 
-      return;     
+      return;
     } else if (strcmp(RUNTIME_ARRAY_BODY(n), "zip") == 0
-               or strcmp(RUNTIME_ARRAY_BODY(n), "nio") == 0)
-    {
+               or strcmp(RUNTIME_ARRAY_BODY(n), "nio") == 0) {
       return;
     }
   }
- 
-  loadLibrary
-    (t, static_cast<local::MyClasspath*>(t->m->classpath)->libraryPath,
-     RUNTIME_ARRAY_BODY(n), not absolute, true);
+
+  loadLibrary(t,
+              static_cast<local::MyClasspath*>(t->m->classpath)->libraryPath,
+              RUNTIME_ARRAY_BODY(n),
+              not absolute,
+              true);
 }
 
-void
-interceptFileOperations(Thread* t, bool updateRuntimeData)
+void interceptFileOperations(Thread* t, bool updateRuntimeData)
 {
   MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
 
@@ -1969,9 +1990,9 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
         = resolveClass(t, roots(t)->bootLoader(), "java/io/File", false);
 
     if (fileClass) {
-      object filePathField = findFieldInClass2
-        (t, fileClass, "path", "Ljava/lang/String;");
-      
+      object filePathField
+          = findFieldInClass2(t, fileClass, "path", "Ljava/lang/String;");
+
       if (filePathField) {
         cp->filePathField = fieldOffset(t, filePathField);
       }
@@ -1983,8 +2004,8 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
         t, roots(t)->bootLoader(), "java/io/FileDescriptor", false);
 
     if (fileDescriptorClass) {
-      object fileDescriptorFdField = findFieldInClass2
-        (t, fileDescriptorClass, "fd", "I");
+      object fileDescriptorFdField
+          = findFieldInClass2(t, fileDescriptorClass, "fd", "I");
 
       if (fileDescriptorFdField) {
         cp->fileDescriptorFdField = fieldOffset(t, fileDescriptorFdField);
@@ -1999,34 +2020,62 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
     if (fileInputStreamClass) {
       PROTECT(t, fileInputStreamClass);
 
-      object fileInputStreamFdField = findFieldInClass2
-        (t, fileInputStreamClass, "fd", "Ljava/io/FileDescriptor;");
+      object fileInputStreamFdField = findFieldInClass2(
+          t, fileInputStreamClass, "fd", "Ljava/io/FileDescriptor;");
 
       if (fileInputStreamFdField) {
         cp->fileInputStreamFdField = fieldOffset(t, fileInputStreamFdField);
 
-        intercept(t, fileInputStreamClass, "open", "(Ljava/lang/String;)V",
-                  voidPointer(openFile), updateRuntimeData);
-  
-        if(findMethodOrNull(t, fileInputStreamClass, "read0", "()I") != 0) {
-          intercept(t, fileInputStreamClass, "read0", "()I",
-                    voidPointer(readByteFromFile), updateRuntimeData);
+        intercept(t,
+                  fileInputStreamClass,
+                  "open",
+                  "(Ljava/lang/String;)V",
+                  voidPointer(openFile),
+                  updateRuntimeData);
+
+        if (findMethodOrNull(t, fileInputStreamClass, "read0", "()I") != 0) {
+          intercept(t,
+                    fileInputStreamClass,
+                    "read0",
+                    "()I",
+                    voidPointer(readByteFromFile),
+                    updateRuntimeData);
         } else {
-          intercept(t, fileInputStreamClass, "read", "()I",
-                    voidPointer(readByteFromFile), updateRuntimeData);
+          intercept(t,
+                    fileInputStreamClass,
+                    "read",
+                    "()I",
+                    voidPointer(readByteFromFile),
+                    updateRuntimeData);
         }
-  
-        intercept(t, fileInputStreamClass, "readBytes", "([BII)I",
-                  voidPointer(readBytesFromFile), updateRuntimeData);
-  
-        intercept(t, fileInputStreamClass, "skip", "(J)J",
-                  voidPointer(skipBytesInFile), updateRuntimeData);
-  
-        intercept(t, fileInputStreamClass, "available", "()I",
-                  voidPointer(availableBytesInFile), updateRuntimeData);
-  
-        intercept(t, fileInputStreamClass, "close0", "()V",
-                  voidPointer(closeFile), updateRuntimeData);
+
+        intercept(t,
+                  fileInputStreamClass,
+                  "readBytes",
+                  "([BII)I",
+                  voidPointer(readBytesFromFile),
+                  updateRuntimeData);
+
+        intercept(t,
+                  fileInputStreamClass,
+                  "skip",
+                  "(J)J",
+                  voidPointer(skipBytesInFile),
+                  updateRuntimeData);
+
+        intercept(t,
+                  fileInputStreamClass,
+                  "available",
+                  "()I",
+                  voidPointer(availableBytesInFile),
+                  updateRuntimeData);
+
+        intercept(t,
+                  fileInputStreamClass,
+                  "close0",
+                  "()V",
+                  voidPointer(closeFile),
+                  updateRuntimeData);
       }
     }
   }
@@ -2038,49 +2087,95 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
     if (zipFileClass) {
       PROTECT(t, zipFileClass);
 
-      object zipFileJzfileField = findFieldInClass2
-        (t, zipFileClass, "jzfile", "J");
+      object zipFileJzfileField
+          = findFieldInClass2(t, zipFileClass, "jzfile", "J");
 
       if (zipFileJzfileField) {
         cp->zipFileJzfileField = fieldOffset(t, zipFileJzfileField);
 
-        intercept(t, zipFileClass, "open", "(Ljava/lang/String;IJZ)J",
-                  voidPointer(openZipFile), updateRuntimeData);
+        intercept(t,
+                  zipFileClass,
+                  "open",
+                  "(Ljava/lang/String;IJZ)J",
+                  voidPointer(openZipFile),
+                  updateRuntimeData);
 
-        intercept(t, zipFileClass, "getTotal", "(J)I",
-                  voidPointer(getZipFileEntryCount), updateRuntimeData);
+        intercept(t,
+                  zipFileClass,
+                  "getTotal",
+                  "(J)I",
+                  voidPointer(getZipFileEntryCount),
+                  updateRuntimeData);
 
-        intercept(t, zipFileClass, "getEntry", "(J[BZ)J",
-                  voidPointer(getZipFileEntry), updateRuntimeData);
+        intercept(t,
+                  zipFileClass,
+                  "getEntry",
+                  "(J[BZ)J",
+                  voidPointer(getZipFileEntry),
+                  updateRuntimeData);
 
-        intercept(t, zipFileClass, "getEntryBytes", "(JI)[B",
-                  voidPointer(getZipFileEntryBytes), updateRuntimeData);
+        intercept(t,
+                  zipFileClass,
+                  "getEntryBytes",
+                  "(JI)[B",
+                  voidPointer(getZipFileEntryBytes),
+                  updateRuntimeData);
 
-        intercept(t, zipFileClass, "getNextEntry", "(JI)J",
-                  voidPointer(getNextZipFileEntry), updateRuntimeData);
+        intercept(t,
+                  zipFileClass,
+                  "getNextEntry",
+                  "(JI)J",
+                  voidPointer(getNextZipFileEntry),
+                  updateRuntimeData);
 
-        intercept(t, zipFileClass, "getEntryMethod", "(J)I",
-                  voidPointer(getZipFileEntryMethod), updateRuntimeData);
+        intercept(t,
+                  zipFileClass,
+                  "getEntryMethod",
+                  "(J)I",
+                  voidPointer(getZipFileEntryMethod),
+                  updateRuntimeData);
 
-        intercept(t, zipFileClass, "freeEntry", "(JJ)V",
-                  voidPointer(freeZipFileEntry), updateRuntimeData);
+        intercept(t,
+                  zipFileClass,
+                  "freeEntry",
+                  "(JJ)V",
+                  voidPointer(freeZipFileEntry),
+                  updateRuntimeData);
 
-        intercept(t, zipFileClass, "read", "(JJJ[BII)I",
-                  voidPointer(readZipFileEntry), updateRuntimeData);
+        intercept(t,
+                  zipFileClass,
+                  "read",
+                  "(JJJ[BII)I",
+                  voidPointer(readZipFileEntry),
+                  updateRuntimeData);
 
-        intercept(t, zipFileClass, "getEntryCSize", "(J)J",
+        intercept(t,
+                  zipFileClass,
+                  "getEntryCSize",
+                  "(J)J",
                   voidPointer(getZipFileEntryCompressedSize),
                   updateRuntimeData);
 
-        intercept(t, zipFileClass, "getEntrySize", "(J)J",
+        intercept(t,
+                  zipFileClass,
+                  "getEntrySize",
+                  "(J)J",
                   voidPointer(getZipFileEntryUncompressedSize),
                   updateRuntimeData);
 
-        intercept(t, zipFileClass, "getZipMessage", "(J)Ljava/lang/String;",
-                  voidPointer(getZipMessage), updateRuntimeData);
+        intercept(t,
+                  zipFileClass,
+                  "getZipMessage",
+                  "(J)Ljava/lang/String;",
+                  voidPointer(getZipMessage),
+                  updateRuntimeData);
 
-        intercept(t, zipFileClass, "close", "(J)V",
-                  voidPointer(closeZipFile), updateRuntimeData);
+        intercept(t,
+                  zipFileClass,
+                  "close",
+                  "(J)V",
+                  voidPointer(closeZipFile),
+                  updateRuntimeData);
       }
     }
   }
@@ -2090,9 +2185,12 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
         t, roots(t)->bootLoader(), "java/util/jar/JarFile", false);
 
     if (jarFileClass) {
-      intercept(t, jarFileClass, "getMetaInfEntryNames",
+      intercept(t,
+                jarFileClass,
+                "getMetaInfEntryNames",
                 "()[Ljava/lang/String;",
-                voidPointer(getJarFileMetaInfEntryNames), updateRuntimeData);
+                voidPointer(getJarFileMetaInfEntryNames),
+                updateRuntimeData);
     }
   }
 
@@ -2111,14 +2209,26 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
     if (fsClass) {
       PROTECT(t, fsClass);
 
-      intercept(t, fsClass, gbaMethodName, "(Ljava/io/File;)I",
-                voidPointer(getFileAttributes), updateRuntimeData);
+      intercept(t,
+                fsClass,
+                gbaMethodName,
+                "(Ljava/io/File;)I",
+                voidPointer(getFileAttributes),
+                updateRuntimeData);
 
-      intercept(t, fsClass, "checkAccess", "(Ljava/io/File;I)Z",
-                voidPointer(checkFileAccess), updateRuntimeData);
-  
-      intercept(t, fsClass, "getLength", "(Ljava/io/File;)J",
-                voidPointer(getFileLength), updateRuntimeData);
+      intercept(t,
+                fsClass,
+                "checkAccess",
+                "(Ljava/io/File;I)Z",
+                voidPointer(checkFileAccess),
+                updateRuntimeData);
+
+      intercept(t,
+                fsClass,
+                "getLength",
+                "(Ljava/io/File;)J",
+                voidPointer(getFileLength),
+                updateRuntimeData);
     }
   }
 
@@ -2143,7 +2253,7 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
             voidPointer(getBootstrapResources),
             updateRuntimeData);
 }
-#endif // AVIAN_OPENJDK_SRC
+#endif  // AVIAN_OPENJDK_SRC
 
 unsigned classDeclaredMethodCount(Thread* t, GcClass* c)
 {
@@ -2166,7 +2276,7 @@ unsigned countMethods(Thread* t, GcClass* c, bool publicOnly)
     GcMethod* vmMethod = cast<GcMethod>(t, table->body()[i]);
     if (((not publicOnly) or (vmMethod->flags() & ACC_PUBLIC))
         and vmMethod->name()->body()[0] != '<') {
-      ++ count;
+      ++count;
     }
   }
   return count;
@@ -2180,7 +2290,7 @@ unsigned countFields(Thread* t, GcClass* c, bool publicOnly)
     for (unsigned i = 0; i < table->length(); ++i) {
       GcField* vmField = cast<GcField>(t, table->body()[i]);
       if (vmField->flags() & ACC_PUBLIC) {
-        ++ count;
+        ++count;
       }
     }
     return count;
@@ -2198,63 +2308,89 @@ unsigned countConstructors(Thread* t, GcClass* c, bool publicOnly)
     if (((not publicOnly) or (vmMethod->flags() & ACC_PUBLIC))
         and strcmp(reinterpret_cast<char*>(vmMethod->name()->body().begin()),
                    "<init>") == 0) {
-      ++ count;
+      ++count;
     }
   }
   return count;
 }
 
 #ifdef HAVE_JexecutableHasRealParameterData
-object
-makeJmethod(Thread* t,
-            uint8_t override,
-            object securityCheckCache,
-            object clazz,
-            uint32_t slot,
-            object name,
-            object returnType,
-            object parameterTypes,
-            object exceptionTypes,
-            uint32_t modifiers,
-            object signature,
-            object genericInfo,
-            object annotations,
-            object parameterAnnotations,
-            object annotationDefault,
-            object methodAccessor,
-            object root,
-            object declaredAnnotations)
+object makeJmethod(Thread* t,
+                   uint8_t override,
+                   object securityCheckCache,
+                   object clazz,
+                   uint32_t slot,
+                   object name,
+                   object returnType,
+                   object parameterTypes,
+                   object exceptionTypes,
+                   uint32_t modifiers,
+                   object signature,
+                   object genericInfo,
+                   object annotations,
+                   object parameterAnnotations,
+                   object annotationDefault,
+                   object methodAccessor,
+                   object root,
+                   object declaredAnnotations)
 {
-  return makeJmethod
-    (t, override, securityCheckCache, 0, 0, declaredAnnotations, clazz, slot,
-     name, returnType, parameterTypes, exceptionTypes, modifiers, signature,
-     genericInfo, annotations, parameterAnnotations, annotationDefault,
-     methodAccessor, root);
+  return makeJmethod(t,
+                     override,
+                     securityCheckCache,
+                     0,
+                     0,
+                     declaredAnnotations,
+                     clazz,
+                     slot,
+                     name,
+                     returnType,
+                     parameterTypes,
+                     exceptionTypes,
+                     modifiers,
+                     signature,
+                     genericInfo,
+                     annotations,
+                     parameterAnnotations,
+                     annotationDefault,
+                     methodAccessor,
+                     root);
 }
 
-object
-makeJconstructor(Thread* t,
-                 uint8_t override,
-                 object securityCheckCache,
-                 object clazz,
-                 uint32_t slot,
-                 object parameterTypes,
-                 object exceptionTypes,
-                 uint32_t modifiers,
-                 object signature,
-                 object genericInfo,
-                 object annotations,
-                 object parameterAnnotations,
-                 object constructorAccessor,
-                 object root,
-                 object declaredAnnotations)
+object makeJconstructor(Thread* t,
+                        uint8_t override,
+                        object securityCheckCache,
+                        object clazz,
+                        uint32_t slot,
+                        object parameterTypes,
+                        object exceptionTypes,
+                        uint32_t modifiers,
+                        object signature,
+                        object genericInfo,
+                        object annotations,
+                        object parameterAnnotations,
+                        object constructorAccessor,
+                        object root,
+                        object declaredAnnotations)
 {
-  return makeJconstructor
-    (t, override, securityCheckCache, 0, 0, declaredAnnotations, clazz, slot,
-     parameterTypes, exceptionTypes, modifiers, signature, genericInfo,
-     annotations, parameterAnnotations, constructorAccessor, root);
+  return makeJconstructor(t,
+                          override,
+                          securityCheckCache,
+                          0,
+                          0,
+                          declaredAnnotations,
+                          clazz,
+                          slot,
+                          parameterTypes,
+                          exceptionTypes,
+                          modifiers,
+                          signature,
+                          genericInfo,
+                          annotations,
+                          parameterAnnotations,
+                          constructorAccessor,
+                          root);
 }
-#endif // HAVE_JexecutableHasRealParameterData
+#endif  // HAVE_JexecutableHasRealParameterData
 
 object makeJmethod(Thread* t, GcMethod* vmMethod, int index)
 {
@@ -2533,8 +2669,7 @@ void setProperty(Thread* t,
   t->m->processor->invoke(t, method, properties, n, v);
 }
 
-bool
-pipeAvailable(int fd, int* available)
+bool pipeAvailable(int fd, int* available)
 {
 #ifdef PLATFORM_WINDOWS
   HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
@@ -2543,7 +2678,7 @@ pipeAvailable(int fd, int* available)
   }
 
   DWORD n;
-  if (PeekNamedPipe(h, 0,0, 0, &n, 0)) {
+  if (PeekNamedPipe(h, 0, 0, 0, &n, 0)) {
     *available = n;
   } else {
     if (GetLastError() != ERROR_BROKEN_PIPE) {
@@ -2558,25 +2693,25 @@ pipeAvailable(int fd, int* available)
 #endif
 }
 
-} // namespace local
+}  // namespace local
 
-} // namespace
+}  // namespace
 
 namespace vm {
 
-Classpath*
-makeClasspath(System* s, Allocator* allocator, const char* javaHome,
-              const char* embedPrefix)
+Classpath* makeClasspath(System* s,
+                         Allocator* allocator,
+                         const char* javaHome,
+                         const char* embedPrefix)
 {
   return new (allocator->allocate(sizeof(local::MyClasspath)))
-    local::MyClasspath(s, allocator, javaHome, embedPrefix);
+      local::MyClasspath(s, allocator, javaHome, embedPrefix);
 }
 
-} // namespace vm
+}  // namespace vm
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_lang_Class_getSuperclass
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_lang_Class_getSuperclass(Thread* t, object, uintptr_t* arguments)
 {
   GcClass* class_
       = cast<GcJclass>(t, reinterpret_cast<object>(arguments[0]))->vmClass();
@@ -2588,23 +2723,22 @@ Avian_java_lang_Class_getSuperclass
   }
 }
 
-extern "C" AVIAN_EXPORT void
-Avian_sun_misc_Unsafe_registerNatives
-(Thread*, object, uintptr_t*)
+extern "C" AVIAN_EXPORT void Avian_sun_misc_Unsafe_registerNatives(Thread*,
+                                                                   object,
+                                                                   uintptr_t*)
 {
   // ignore
 }
 
-extern "C" AVIAN_EXPORT void
-Avian_sun_misc_Perf_registerNatives
-(Thread*, object, uintptr_t*)
+extern "C" AVIAN_EXPORT void Avian_sun_misc_Perf_registerNatives(Thread*,
+                                                                 object,
+                                                                 uintptr_t*)
 {
   // ignore
 }
 
 extern "C" AVIAN_EXPORT int64_t
-Avian_sun_misc_Perf_createLong
-(Thread* t, object, uintptr_t*)
+    Avian_sun_misc_Perf_createLong(Thread* t, object, uintptr_t*)
 {
   return reinterpret_cast<int64_t>(
       t->m->processor->invoke(t,
@@ -2618,29 +2752,30 @@ Avian_sun_misc_Perf_createLong
 }
 
 extern "C" AVIAN_EXPORT int64_t
-Avian_sun_misc_Unsafe_addressSize
-(Thread*, object, uintptr_t*)
+    Avian_sun_misc_Unsafe_addressSize(Thread*, object, uintptr_t*)
 {
   return BytesPerWord;
 }
 
 extern "C" AVIAN_EXPORT int64_t
-Avian_sun_misc_Unsafe_defineClass__Ljava_lang_String_2_3BIILjava_lang_ClassLoader_2Ljava_security_ProtectionDomain_2
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_defineClass__Ljava_lang_String_2_3BIILjava_lang_ClassLoader_2Ljava_security_ProtectionDomain_2(
+        Thread* t,
+        object,
+        uintptr_t* arguments)
 {
-  //object name = reinterpret_cast<object>(arguments[1]);
+  // object name = reinterpret_cast<object>(arguments[1]);
   GcByteArray* data
       = cast<GcByteArray>(t, reinterpret_cast<object>(arguments[2]));
   int32_t offset = arguments[3];
   int32_t length = arguments[4];
   GcClassLoader* loader
       = cast<GcClassLoader>(t, reinterpret_cast<object>(arguments[5]));
-  //object domain = reinterpret_cast<object>(arguments[6]);
+  // object domain = reinterpret_cast<object>(arguments[6]);
 
   uint8_t* buffer = static_cast<uint8_t*>(t->m->heap->allocate(length));
 
-  THREAD_RESOURCE2(t, uint8_t*, buffer, int, length,
-                   t->m->heap->free(buffer, length));
+  THREAD_RESOURCE2(
+      t, uint8_t*, buffer, int, length, t->m->heap->free(buffer, length));
 
   memcpy(buffer, &data->body()[offset], length);
 
@@ -2649,8 +2784,9 @@ Avian_sun_misc_Unsafe_defineClass__Ljava_lang_String_2_3BIILjava_lang_ClassLoade
 }
 
 extern "C" AVIAN_EXPORT int64_t
-Avian_sun_misc_Unsafe_allocateInstance
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_allocateInstance(Thread* t,
+                                           object,
+                                           uintptr_t* arguments)
 {
   GcClass* c
       = cast<GcJclass>(t, reinterpret_cast<object>(arguments[1]))->vmClass();
@@ -2662,8 +2798,9 @@ Avian_sun_misc_Unsafe_allocateInstance
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_staticFieldOffset
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_staticFieldOffset(Thread* t,
+                                            object,
+                                            uintptr_t* arguments)
 {
   GcJfield* jfield = cast<GcJfield>(t, reinterpret_cast<object>(arguments[1]));
   return cast<GcField>(
@@ -2673,8 +2810,9 @@ Avian_sun_misc_Unsafe_staticFieldOffset
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_staticFieldBase
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_staticFieldBase(Thread* t,
+                                          object,
+                                          uintptr_t* arguments)
 {
   return reinterpret_cast<int64_t>(
       cast<GcJfield>(t, reinterpret_cast<object>(arguments[1]))
@@ -2684,8 +2822,9 @@ Avian_sun_misc_Unsafe_staticFieldBase
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_objectFieldOffset
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_objectFieldOffset(Thread* t,
+                                            object,
+                                            uintptr_t* arguments)
 {
   GcJfield* jfield = cast<GcJfield>(t, reinterpret_cast<object>(arguments[1]));
   return cast<GcField>(
@@ -2695,183 +2834,211 @@ Avian_sun_misc_Unsafe_objectFieldOffset
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getShort__Ljava_lang_Object_2J
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getShort__Ljava_lang_Object_2J(Thread*,
+                                                         object,
+                                                         uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
 
   return fieldAtOffset<int16_t>(o, offset);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getChar__Ljava_lang_Object_2J
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getChar__Ljava_lang_Object_2J(Thread*,
+                                                        object,
+                                                        uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
 
   return fieldAtOffset<uint16_t>(o, offset);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getInt__Ljava_lang_Object_2J
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getInt__Ljava_lang_Object_2J(Thread*,
+                                                       object,
+                                                       uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
 
   return fieldAtOffset<int32_t>(o, offset);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getFloat__Ljava_lang_Object_2J
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getFloat__Ljava_lang_Object_2J(Thread*,
+                                                         object,
+                                                         uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
 
   return fieldAtOffset<int32_t>(o, offset);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getLong__Ljava_lang_Object_2J
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getLong__Ljava_lang_Object_2J(Thread*,
+                                                        object,
+                                                        uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
 
   return fieldAtOffset<int64_t>(o, offset);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getDouble__Ljava_lang_Object_2J
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getDouble__Ljava_lang_Object_2J(Thread* t,
+                                                          object method,
+                                                          uintptr_t* arguments)
 {
-  return Avian_sun_misc_Unsafe_getLong__Ljava_lang_Object_2J
-    (t, method, arguments);
+  return Avian_sun_misc_Unsafe_getLong__Ljava_lang_Object_2J(
+      t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putByte__Ljava_lang_Object_2JB
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putByte__Ljava_lang_Object_2JB(Thread*,
+                                                         object,
+                                                         uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
   int8_t value = arguments[4];
 
   fieldAtOffset<int8_t>(o, offset) = value;
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putShort__Ljava_lang_Object_2JS
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putShort__Ljava_lang_Object_2JS(Thread*,
+                                                          object,
+                                                          uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
   int16_t value = arguments[4];
 
   fieldAtOffset<int16_t>(o, offset) = value;
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putChar__Ljava_lang_Object_2JC
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putChar__Ljava_lang_Object_2JC(Thread*,
+                                                         object,
+                                                         uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
   uint16_t value = arguments[4];
 
   fieldAtOffset<uint16_t>(o, offset) = value;
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putInt__Ljava_lang_Object_2JI
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putInt__Ljava_lang_Object_2JI(Thread*,
+                                                        object,
+                                                        uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
   int32_t value = arguments[4];
 
   fieldAtOffset<int32_t>(o, offset) = value;
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putFloat__Ljava_lang_Object_2JF
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putFloat__Ljava_lang_Object_2JF(Thread*,
+                                                          object,
+                                                          uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
   int32_t value = arguments[4];
 
   fieldAtOffset<int32_t>(o, offset) = value;
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getByte__Ljava_lang_Object_2J
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getByte__Ljava_lang_Object_2J(Thread*,
+                                                        object,
+                                                        uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
 
   return fieldAtOffset<int8_t>(o, offset);
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_getBoolean__Ljava_lang_Object_2J
-(Thread* t, object method, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_getBoolean__Ljava_lang_Object_2J(Thread* t,
+                                                           object method,
+                                                           uintptr_t* arguments)
 {
-  return Avian_sun_misc_Unsafe_getByte__Ljava_lang_Object_2J
-    (t, method, arguments);
+  return Avian_sun_misc_Unsafe_getByte__Ljava_lang_Object_2J(
+      t, method, arguments);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putBoolean__Ljava_lang_Object_2JZ
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putBoolean__Ljava_lang_Object_2JZ(
+        Thread*,
+        object,
+        uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
   uint8_t value = arguments[4];
 
   fieldAtOffset<uint8_t>(o, offset) = value;
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_putLong__Ljava_lang_Object_2JJ
-(Thread*, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_putLong__Ljava_lang_Object_2JJ(Thread*,
+                                                         object,
+                                                         uintptr_t* arguments)
 {
   object o = reinterpret_cast<object>(arguments[1]);
-  int64_t offset; memcpy(&offset, arguments + 2, 8);
-  int64_t value; memcpy(&value, arguments + 4, 8);
+  int64_t offset;
+  memcpy(&offset, arguments + 2, 8);
+  int64_t value;
+  memcpy(&value, arguments + 4, 8);
 
   fieldAtOffset<int64_t>(o, offset) = value;
 }
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_sun_misc_Unsafe_pageSize
-(Thread*, object, uintptr_t*)
+    Avian_sun_misc_Unsafe_pageSize(Thread*, object, uintptr_t*)
 {
   return local::PageSize;
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_ensureClassInitialized
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_ensureClassInitialized(Thread* t,
+                                                 object,
+                                                 uintptr_t* arguments)
 {
   initClass(
       t, cast<GcJclass>(t, reinterpret_cast<object>(arguments[1]))->vmClass());
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_monitorEnter
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_monitorEnter(Thread* t, object, uintptr_t* arguments)
 {
   acquire(t, reinterpret_cast<object>(arguments[1]));
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-Avian_sun_misc_Unsafe_monitorExit
-(Thread* t, object, uintptr_t* arguments)
+    Avian_sun_misc_Unsafe_monitorExit(Thread* t, object, uintptr_t* arguments)
 {
   release(t, reinterpret_cast<object>(arguments[1]));
 }
@@ -2880,25 +3047,23 @@ namespace {
 
 namespace local {
 
-extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetInterfaceVersion)()
+extern "C" AVIAN_EXPORT jint JNICALL EXPORT(JVM_GetInterfaceVersion)()
 {
   return local::InterfaceVersion;
 }
 
-extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_IHashCode)(Thread* t, jobject o)
+extern "C" AVIAN_EXPORT jint JNICALL EXPORT(JVM_IHashCode)(Thread* t, jobject o)
 {
   ENTER(t, Thread::ActiveState);
 
   return o ? objectHash(t, *o) : 0;
 }
 
-uint64_t
-jvmWait(Thread* t, uintptr_t* arguments)
+uint64_t jvmWait(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
-  jlong milliseconds; memcpy(&milliseconds, arguments + 1, sizeof(jlong));
+  jlong milliseconds;
+  memcpy(&milliseconds, arguments + 1, sizeof(jlong));
 
   vm::wait(t, *o, milliseconds);
 
@@ -2906,7 +3071,7 @@ jvmWait(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_MonitorWait)(Thread* t, jobject o, jlong milliseconds)
+    EXPORT(JVM_MonitorWait)(Thread* t, jobject o, jlong milliseconds)
 {
   uintptr_t arguments[1 + (sizeof(jlong) / BytesPerWord)];
   arguments[0] = reinterpret_cast<uintptr_t>(o);
@@ -2915,8 +3080,7 @@ EXPORT(JVM_MonitorWait)(Thread* t, jobject o, jlong milliseconds)
   run(t, jvmWait, arguments);
 }
 
-uint64_t
-jvmNotify(Thread* t, uintptr_t* arguments)
+uint64_t jvmNotify(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
 
@@ -2926,15 +3090,14 @@ jvmNotify(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_MonitorNotify)(Thread* t, jobject o)
+    EXPORT(JVM_MonitorNotify)(Thread* t, jobject o)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o)};
 
   run(t, jvmNotify, arguments);
 }
 
-uint64_t
-jvmNotifyAll(Thread* t, uintptr_t* arguments)
+uint64_t jvmNotifyAll(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
 
@@ -2944,31 +3107,28 @@ jvmNotifyAll(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_MonitorNotifyAll)(Thread* t, jobject o)
+    EXPORT(JVM_MonitorNotifyAll)(Thread* t, jobject o)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o)};
 
   run(t, jvmNotifyAll, arguments);
 }
 
-uint64_t
-jvmClone(Thread* t, uintptr_t* arguments)
+uint64_t jvmClone(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
 
   return reinterpret_cast<uint64_t>(makeLocalReference(t, clone(t, *o)));
 }
 
-extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_Clone)(Thread* t, jobject o)
+extern "C" AVIAN_EXPORT jobject JNICALL EXPORT(JVM_Clone)(Thread* t, jobject o)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o)};
 
   return reinterpret_cast<jobject>(run(t, jvmClone, arguments));
 }
 
-uint64_t
-jvmInternString(Thread* t, uintptr_t* arguments)
+uint64_t jvmInternString(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
 
@@ -2976,27 +3136,25 @@ jvmInternString(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jstring JNICALL
-EXPORT(JVM_InternString)(Thread* t, jstring s)
+    EXPORT(JVM_InternString)(Thread* t, jstring s)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(s) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(s)};
 
   return reinterpret_cast<jstring>(run(t, jvmInternString, arguments));
 }
 
 extern "C" AVIAN_EXPORT jlong JNICALL
-EXPORT(JVM_CurrentTimeMillis)(Thread* t, jclass)
+    EXPORT(JVM_CurrentTimeMillis)(Thread* t, jclass)
 {
   return t->m->system->now();
 }
 
-extern "C" AVIAN_EXPORT jlong JNICALL
-EXPORT(JVM_NanoTime)(Thread* t, jclass)
+extern "C" AVIAN_EXPORT jlong JNICALL EXPORT(JVM_NanoTime)(Thread* t, jclass)
 {
   return t->m->system->now() * 1000 * 1000;
 }
 
-uint64_t
-jvmArrayCopy(Thread* t, uintptr_t* arguments)
+uint64_t jvmArrayCopy(Thread* t, uintptr_t* arguments)
 {
   jobject src = reinterpret_cast<jobject>(arguments[0]);
   jint srcOffset = arguments[1];
@@ -3009,21 +3167,24 @@ jvmArrayCopy(Thread* t, uintptr_t* arguments)
   return 1;
 }
 
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_ArrayCopy)(Thread* t, jclass, jobject src, jint srcOffset,
-                      jobject dst, jint dstOffset, jint length)
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(JVM_ArrayCopy)(Thread* t,
+                                                           jclass,
+                                                           jobject src,
+                                                           jint srcOffset,
+                                                           jobject dst,
+                                                           jint dstOffset,
+                                                           jint length)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(src),
-                            static_cast<uintptr_t>(srcOffset),
-                            reinterpret_cast<uintptr_t>(dst),
-                            static_cast<uintptr_t>(dstOffset),
-                            static_cast<uintptr_t>(length) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(src),
+                           static_cast<uintptr_t>(srcOffset),
+                           reinterpret_cast<uintptr_t>(dst),
+                           static_cast<uintptr_t>(dstOffset),
+                           static_cast<uintptr_t>(length)};
 
   run(t, jvmArrayCopy, arguments);
 }
 
-uint64_t
-jvmInitProperties(Thread* t, uintptr_t* arguments)
+uint64_t jvmInitProperties(Thread* t, uintptr_t* arguments)
 {
   jobject properties = reinterpret_cast<jobject>(arguments[0]);
 
@@ -3047,54 +3208,64 @@ jvmInitProperties(Thread* t, uintptr_t* arguments)
 
   local::setProperty(t, method, *properties, "java.io.tmpdir", buffer);
   local::setProperty(t, method, *properties, "java.home", buffer);
-  local::setProperty(t, method, *properties, "user.home",
-                     _wgetenv(L"USERPROFILE"), "%ls");
+  local::setProperty(
+      t, method, *properties, "user.home", _wgetenv(L"USERPROFILE"), "%ls");
 
   GetCurrentDirectory(MAX_PATH, buffer);
 
   local::setProperty(t, method, *properties, "user.dir", buffer);
-#else // not PLATFORM_WINDOWS
+#else  // not PLATFORM_WINDOWS
   local::setProperty(t, method, *properties, "line.separator", "\n");
   local::setProperty(t, method, *properties, "file.separator", "/");
   local::setProperty(t, method, *properties, "path.separator", ":");
-#  ifdef __APPLE__
+#ifdef __APPLE__
   local::setProperty(t, method, *properties, "os.name", "Mac OS X");
-#  elif defined __FreeBSD__
+#elif defined __FreeBSD__
   local::setProperty(t, method, *properties, "os.name", "FreeBSD");
-#  else // not __APPLE__
+#else   // not __APPLE__
   local::setProperty(t, method, *properties, "os.name", "Linux");
-#  endif // not __APPLE__
+#endif  // not __APPLE__
   local::setProperty(t, method, *properties, "java.io.tmpdir", "/tmp");
   local::setProperty(t, method, *properties, "user.home", getenv("HOME"));
 
   char buffer[PATH_MAX];
-  local::setProperty(t, method, *properties, "user.dir",
-                     getcwd(buffer, PATH_MAX));
-#endif // not PLATFORM_WINDOWS
+  local::setProperty(
+      t, method, *properties, "user.dir", getcwd(buffer, PATH_MAX));
+#endif  // not PLATFORM_WINDOWS
 
-  local::setProperty(t, method, *properties, "java.protocol.handler.pkgs",
-                     "avian");
+  local::setProperty(
+      t, method, *properties, "java.protocol.handler.pkgs", "avian");
 
-  local::setProperty(t, method, *properties, "java.vm.vendor",
-                     "Avian Contributors");
+  local::setProperty(
+      t, method, *properties, "java.vm.vendor", "Avian Contributors");
 
-  local::setProperty(t, method, *properties, "java.vm.name","Avian");
+  local::setProperty(t, method, *properties, "java.vm.name", "Avian");
 #ifdef AVIAN_VERSION
-  local::setProperty(t, method, *properties, "java.vm.version",AVIAN_VERSION);
+  local::setProperty(t, method, *properties, "java.vm.version", AVIAN_VERSION);
 #endif
 #ifdef AVIAN_INFO
-  local::setProperty(t, method, *properties, "java.vm.info",AVIAN_INFO);
+  local::setProperty(t, method, *properties, "java.vm.info", AVIAN_INFO);
 #endif
 
-  local::setProperty(t, method, *properties, "java.vm.specification.name", "Java Virtual Machine Specification");
+  local::setProperty(t,
+                     method,
+                     *properties,
+                     "java.vm.specification.name",
+                     "Java Virtual Machine Specification");
 
-  local::setProperty
-    (t, method, *properties, "java.home",
-     static_cast<local::MyClasspath*>(t->m->classpath)->javaHome);
+  local::setProperty(
+      t,
+      method,
+      *properties,
+      "java.home",
+      static_cast<local::MyClasspath*>(t->m->classpath)->javaHome);
 
-  local::setProperty
-    (t, method, *properties, "sun.boot.library.path",
-     static_cast<local::MyClasspath*>(t->m->classpath)->libraryPath);
+  local::setProperty(
+      t,
+      method,
+      *properties,
+      "sun.boot.library.path",
+      static_cast<local::MyClasspath*>(t->m->classpath)->libraryPath);
 
   local::setProperty(
       t,
@@ -3119,91 +3290,89 @@ jvmInitProperties(Thread* t, uintptr_t* arguments)
   for (unsigned i = 0; i < t->m->propertyCount; ++i) {
     const char* start = t->m->properties[i];
     const char* p = start;
-    while (*p and *p != '=') ++p;
+    while (*p and *p != '=')
+      ++p;
 
     if (*p == '=') {
       THREAD_RUNTIME_ARRAY(t, char, name, (p - start) + 1);
       memcpy(RUNTIME_ARRAY_BODY(name), start, p - start);
       RUNTIME_ARRAY_BODY(name)[p - start] = 0;
-      local::setProperty
-        (t, method, *properties, RUNTIME_ARRAY_BODY(name), p + 1);
+      local::setProperty(
+          t, method, *properties, RUNTIME_ARRAY_BODY(name), p + 1);
     }
-  }  
+  }
 
   return reinterpret_cast<uint64_t>(properties);
 }
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_InitProperties)(Thread* t, jobject properties)
+    EXPORT(JVM_InitProperties)(Thread* t, jobject properties)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(properties) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(properties)};
 
   return reinterpret_cast<jobject>(run(t, jvmInitProperties, arguments));
 }
 
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_OnExit)(void (*)(void)) { abort(); }
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(JVM_OnExit)(void (*)(void))
+{
+  abort();
+}
 
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_Exit)(jint code)
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(JVM_Exit)(jint code)
 {
   exit(code);
 }
 
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_Halt)(jint code)
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(JVM_Halt)(jint code)
 {
   exit(code);
 }
 
-uint64_t
-jvmGC(Thread* t, uintptr_t*)
+uint64_t jvmGC(Thread* t, uintptr_t*)
 {
   collect(t, Heap::MajorCollection);
 
   return 1;
 }
 
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_GC)()
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(JVM_GC)()
 {
   Thread* t = static_cast<Thread*>(local::globalMachine->localThread->get());
-  
+
   run(t, jvmGC, 0);
 }
 
-extern "C" AVIAN_EXPORT jlong JNICALL
-EXPORT(JVM_MaxObjectInspectionAge)(void)
+extern "C" AVIAN_EXPORT jlong JNICALL EXPORT(JVM_MaxObjectInspectionAge)(void)
 {
   return 0;
 }
 
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_TraceInstructions)(jboolean) { abort(); }
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(JVM_TraceInstructions)(jboolean)
+{
+  abort();
+}
 
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_TraceMethodCalls)(jboolean) { abort(); }
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(JVM_TraceMethodCalls)(jboolean)
+{
+  abort();
+}
 
-extern "C" AVIAN_EXPORT jlong JNICALL
-EXPORT(JVM_TotalMemory)()
+extern "C" AVIAN_EXPORT jlong JNICALL EXPORT(JVM_TotalMemory)()
 {
   return 0;
 }
 
-extern "C" AVIAN_EXPORT jlong JNICALL
-EXPORT(JVM_FreeMemory)()
+extern "C" AVIAN_EXPORT jlong JNICALL EXPORT(JVM_FreeMemory)()
 {
   return 0;
 }
 
-extern "C" AVIAN_EXPORT jlong JNICALL
-EXPORT(JVM_MaxMemory)()
+extern "C" AVIAN_EXPORT jlong JNICALL EXPORT(JVM_MaxMemory)()
 {
   return local::globalMachine->heap->limit();
 }
 
-extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_ActiveProcessorCount)()
+extern "C" AVIAN_EXPORT jint JNICALL EXPORT(JVM_ActiveProcessorCount)()
 {
 #ifdef PLATFORM_WINDOWS
   SYSTEM_INFO si;
@@ -3214,41 +3383,40 @@ EXPORT(JVM_ActiveProcessorCount)()
 #endif
 }
 
-uint64_t
-jvmLoadLibrary(Thread* t, uintptr_t* arguments)
+uint64_t jvmLoadLibrary(Thread* t, uintptr_t* arguments)
 {
   const char* path = reinterpret_cast<const char*>(arguments[0]);
 
   THREAD_RUNTIME_ARRAY(t, char, p, strlen(path) + 1);
   replace('\\', '/', RUNTIME_ARRAY_BODY(p), path);
 
-  return reinterpret_cast<uint64_t>
-    (loadLibrary
-     (t, static_cast<local::MyClasspath*>(t->m->classpath)->libraryPath,
-      RUNTIME_ARRAY_BODY(p), false, false));
+  return reinterpret_cast<uint64_t>(loadLibrary(
+      t,
+      static_cast<local::MyClasspath*>(t->m->classpath)->libraryPath,
+      RUNTIME_ARRAY_BODY(p),
+      false,
+      false));
 }
 
-extern "C" AVIAN_EXPORT void* JNICALL
-EXPORT(JVM_LoadLibrary)(const char* path)
+extern "C" AVIAN_EXPORT void* JNICALL EXPORT(JVM_LoadLibrary)(const char* path)
 {
   Thread* t = static_cast<Thread*>(local::globalMachine->localThread->get());
-  
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(path) };
 
-  return reinterpret_cast<void*>(run(t, jvmLoadLibrary, arguments));  
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(path)};
+
+  return reinterpret_cast<void*>(run(t, jvmLoadLibrary, arguments));
 }
 
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_UnloadLibrary)(void*)
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(JVM_UnloadLibrary)(void*)
 {
   // todo: implement this correctly for POSIX and Windows
 }
 
 extern "C" AVIAN_EXPORT void* JNICALL
-EXPORT(JVM_FindLibraryEntry)(void* library, const char* name)
+    EXPORT(JVM_FindLibraryEntry)(void* library, const char* name)
 {
   Thread* t = static_cast<Thread*>(local::globalMachine->localThread->get());
-  
+
   ENTER(t, Thread::ActiveState);
 
   if (library == RTLD_DEFAULT) {
@@ -3265,16 +3433,17 @@ EXPORT(JVM_FindLibraryEntry)(void* library, const char* name)
 }
 
 extern "C" AVIAN_EXPORT jboolean JNICALL
-EXPORT(JVM_IsSupportedJNIVersion)(jint version)
+    EXPORT(JVM_IsSupportedJNIVersion)(jint version)
 {
   return version <= JNI_VERSION_1_6;
 }
 
-extern "C" AVIAN_EXPORT jboolean JNICALL
-EXPORT(JVM_IsNaN)(jdouble) { abort(); }
+extern "C" AVIAN_EXPORT jboolean JNICALL EXPORT(JVM_IsNaN)(jdouble)
+{
+  abort();
+}
 
-uint64_t
-jvmFillInStackTrace(Thread* t, uintptr_t* arguments)
+uint64_t jvmFillInStackTrace(Thread* t, uintptr_t* arguments)
 {
   GcThrowable* throwable
       = cast<GcThrowable>(t, *reinterpret_cast<jobject>(arguments[0]));
@@ -3286,26 +3455,28 @@ jvmFillInStackTrace(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_FillInStackTrace)(Thread* t, jobject throwable)
+    EXPORT(JVM_FillInStackTrace)(Thread* t, jobject throwable)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(throwable) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(throwable)};
 
   run(t, jvmFillInStackTrace, arguments);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_PrintStackTrace)(Thread*, jobject, jobject) { abort(); }
+    EXPORT(JVM_PrintStackTrace)(Thread*, jobject, jobject)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetStackTraceDepth)(Thread* t, jobject throwable)
+    EXPORT(JVM_GetStackTraceDepth)(Thread* t, jobject throwable)
 {
   ENTER(t, Thread::ActiveState);
 
   return objectArrayLength(t, cast<GcThrowable>(t, *throwable)->trace());
 }
 
-uint64_t
-jvmGetStackTraceElement(Thread* t, uintptr_t* arguments)
+uint64_t jvmGetStackTraceElement(Thread* t, uintptr_t* arguments)
 {
   jobject throwable = reinterpret_cast<jobject>(arguments[0]);
   jint index = arguments[1];
@@ -3321,49 +3492,56 @@ jvmGetStackTraceElement(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_GetStackTraceElement)(Thread* t, jobject throwable, jint index)
+    EXPORT(JVM_GetStackTraceElement)(Thread* t, jobject throwable, jint index)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(throwable),
-                            static_cast<uintptr_t>(index) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(throwable), static_cast<uintptr_t>(index)};
 
   return reinterpret_cast<jobject>(run(t, jvmGetStackTraceElement, arguments));
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_InitializeCompiler) (Thread*, jclass) { abort(); }
+    EXPORT(JVM_InitializeCompiler)(Thread*, jclass)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jboolean JNICALL
-EXPORT(JVM_IsSilentCompiler)(Thread*, jclass) { abort(); }
+    EXPORT(JVM_IsSilentCompiler)(Thread*, jclass)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jboolean JNICALL
-EXPORT(JVM_CompileClass)(Thread*, jclass, jclass)
+    EXPORT(JVM_CompileClass)(Thread*, jclass, jclass)
 {
   return false;
 }
 
 extern "C" AVIAN_EXPORT jboolean JNICALL
-EXPORT(JVM_CompileClasses)(Thread*, jclass, jstring)
+    EXPORT(JVM_CompileClasses)(Thread*, jclass, jstring)
 {
   return false;
 }
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_CompilerCommand)(Thread*, jclass, jobject) { abort(); }
+    EXPORT(JVM_CompilerCommand)(Thread*, jclass, jobject)
+{
+  abort();
+}
 
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_EnableCompiler)(Thread*, jclass)
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(JVM_EnableCompiler)(Thread*, jclass)
 {
   // ignore
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_DisableCompiler)(Thread*, jclass)
+    EXPORT(JVM_DisableCompiler)(Thread*, jclass)
 {
   // ignore
 }
 
-uint64_t
-jvmStartThread(Thread* t, uintptr_t* arguments)
+uint64_t jvmStartThread(Thread* t, uintptr_t* arguments)
 {
   jobject thread = reinterpret_cast<jobject>(arguments[0]);
 
@@ -3371,18 +3549,21 @@ jvmStartThread(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_StartThread)(Thread* t, jobject thread)
+    EXPORT(JVM_StartThread)(Thread* t, jobject thread)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(thread) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(thread)};
 
   run(t, jvmStartThread, arguments);
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_StopThread)(Thread*, jobject, jobject) { abort(); }
+    EXPORT(JVM_StopThread)(Thread*, jobject, jobject)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jboolean JNICALL
-EXPORT(JVM_IsThreadAlive)(Thread* t, jobject thread)
+    EXPORT(JVM_IsThreadAlive)(Thread* t, jobject thread)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3390,28 +3571,31 @@ EXPORT(JVM_IsThreadAlive)(Thread* t, jobject thread)
   return p and (p->flags & Thread::ActiveFlag) != 0;
 }
 
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_SuspendThread)(Thread*, jobject) { abort(); }
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(JVM_SuspendThread)(Thread*, jobject)
+{
+  abort();
+}
+
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(JVM_ResumeThread)(Thread*, jobject)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_ResumeThread)(Thread*, jobject) { abort(); }
-
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_SetThreadPriority)(Thread*, jobject, jint)
+    EXPORT(JVM_SetThreadPriority)(Thread*, jobject, jint)
 {
   // ignore
 }
 
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_Yield)(Thread* t, jclass)
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(JVM_Yield)(Thread* t, jclass)
 {
   t->m->system->yield();
 }
 
-uint64_t
-jvmSleep(Thread* t, uintptr_t* arguments)
+uint64_t jvmSleep(Thread* t, uintptr_t* arguments)
 {
-  jlong milliseconds; memcpy(&milliseconds, arguments, sizeof(jlong));
+  jlong milliseconds;
+  memcpy(&milliseconds, arguments, sizeof(jlong));
 
   if (milliseconds <= 0) {
     milliseconds = 1;
@@ -3430,7 +3614,7 @@ jvmSleep(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_Sleep)(Thread* t, jclass, jlong milliseconds)
+    EXPORT(JVM_Sleep)(Thread* t, jclass, jlong milliseconds)
 {
   uintptr_t arguments[sizeof(jlong) / BytesPerWord];
   memcpy(arguments, &milliseconds, sizeof(jlong));
@@ -3439,7 +3623,7 @@ EXPORT(JVM_Sleep)(Thread* t, jclass, jlong milliseconds)
 }
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_CurrentThread)(Thread* t, jclass)
+    EXPORT(JVM_CurrentThread)(Thread* t, jclass)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3447,10 +3631,12 @@ EXPORT(JVM_CurrentThread)(Thread* t, jclass)
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_CountStackFrames)(Thread*, jobject) { abort(); }
+    EXPORT(JVM_CountStackFrames)(Thread*, jobject)
+{
+  abort();
+}
 
-uint64_t
-jvmInterrupt(Thread* t, uintptr_t* arguments)
+uint64_t jvmInterrupt(Thread* t, uintptr_t* arguments)
 {
   threadInterrupt(t,
                   cast<GcThread>(t, *reinterpret_cast<jobject>(arguments[0])));
@@ -3459,15 +3645,14 @@ jvmInterrupt(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_Interrupt)(Thread* t, jobject thread)
+    EXPORT(JVM_Interrupt)(Thread* t, jobject thread)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(thread) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(thread)};
 
   run(t, jvmInterrupt, arguments);
 }
 
-uint64_t
-jvmIsInterrupted(Thread* t, uintptr_t* arguments)
+uint64_t jvmIsInterrupted(Thread* t, uintptr_t* arguments)
 {
   jobject thread = reinterpret_cast<jobject>(arguments[0]);
   jboolean clear = arguments[1];
@@ -3476,15 +3661,14 @@ jvmIsInterrupted(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jboolean JNICALL
-EXPORT(JVM_IsInterrupted)(Thread* t, jobject thread, jboolean clear)
+    EXPORT(JVM_IsInterrupted)(Thread* t, jobject thread, jboolean clear)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(thread), clear };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(thread), clear};
 
   return run(t, jvmIsInterrupted, arguments);
 }
 
-uint64_t
-jvmHoldsLock(Thread* t, uintptr_t* arguments)
+uint64_t jvmHoldsLock(Thread* t, uintptr_t* arguments)
 {
   GcMonitor* m
       = objectMonitor(t, *reinterpret_cast<jobject>(arguments[0]), false);
@@ -3493,21 +3677,25 @@ jvmHoldsLock(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jboolean JNICALL
-EXPORT(JVM_HoldsLock)(Thread* t, jclass, jobject o)
+    EXPORT(JVM_HoldsLock)(Thread* t, jclass, jobject o)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o)};
 
   return run(t, jvmHoldsLock, arguments);
 }
 
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_DumpAllStacks)(Thread*, jclass) { abort(); }
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(JVM_DumpAllStacks)(Thread*, jclass)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jobjectArray JNICALL
-EXPORT(JVM_GetAllThreads)(Thread*, jclass) { abort(); }
+    EXPORT(JVM_GetAllThreads)(Thread*, jclass)
+{
+  abort();
+}
 
-uint64_t
-jvmDumpThreads(Thread* t, uintptr_t* arguments)
+uint64_t jvmDumpThreads(Thread* t, uintptr_t* arguments)
 {
   jobjectArray threads = reinterpret_cast<jobjectArray>(arguments[0]);
 
@@ -3521,8 +3709,7 @@ jvmDumpThreads(Thread* t, uintptr_t* arguments)
   PROTECT(t, result);
 
   for (unsigned threadsIndex = 0; threadsIndex < threadsLength;
-       ++ threadsIndex)
-  {
+       ++threadsIndex) {
     Thread* peer = reinterpret_cast<Thread*>(
         cast<GcThread>(t,
                        objectArrayBody(
@@ -3538,7 +3725,7 @@ jvmDumpThreads(Thread* t, uintptr_t* arguments)
           = makeObjectArray(t, type(t, GcStackTraceElement::Type), traceLength);
       PROTECT(t, array);
 
-      for (unsigned traceIndex = 0; traceIndex < traceLength; ++ traceIndex) {
+      for (unsigned traceIndex = 0; traceIndex < traceLength; ++traceIndex) {
         object ste = makeStackTraceElement(
             t, cast<GcTraceElement>(t, objectArrayBody(t, trace, traceIndex)));
         setField(t, array, ArrayBody + (traceIndex * BytesPerWord), ste);
@@ -3552,18 +3739,19 @@ jvmDumpThreads(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jobjectArray JNICALL
-EXPORT(JVM_DumpThreads)(Thread* t, jclass, jobjectArray threads)
+    EXPORT(JVM_DumpThreads)(Thread* t, jclass, jobjectArray threads)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(threads) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(threads)};
 
   return reinterpret_cast<jobjectArray>(run(t, jvmDumpThreads, arguments));
 }
 
-extern "C" AVIAN_EXPORT jclass JNICALL
-EXPORT(JVM_CurrentLoadedClass)(Thread*) { abort(); }
+extern "C" AVIAN_EXPORT jclass JNICALL EXPORT(JVM_CurrentLoadedClass)(Thread*)
+{
+  abort();
+}
 
-extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_CurrentClassLoader)(Thread*)
+extern "C" AVIAN_EXPORT jobject JNICALL EXPORT(JVM_CurrentClassLoader)(Thread*)
 {
   // just return null, i.e. tell SecurityManager.currentClassLoader
   // all permissions are granted, since Avian doesn't do any internal
@@ -3571,8 +3759,7 @@ EXPORT(JVM_CurrentClassLoader)(Thread*)
   return 0;
 }
 
-uint64_t
-jvmGetClassContext(Thread* t, uintptr_t*)
+uint64_t jvmGetClassContext(Thread* t, uintptr_t*)
 {
   object trace = getTrace(t, 1);
   PROTECT(t, trace);
@@ -3595,19 +3782,22 @@ jvmGetClassContext(Thread* t, uintptr_t*)
 }
 
 extern "C" AVIAN_EXPORT jobjectArray JNICALL
-EXPORT(JVM_GetClassContext)(Thread* t)
+    EXPORT(JVM_GetClassContext)(Thread* t)
 {
   return reinterpret_cast<jobjectArray>(run(t, jvmGetClassContext, 0));
 }
 
-extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_ClassDepth)(Thread*, jstring) { abort(); }
+extern "C" AVIAN_EXPORT jint JNICALL EXPORT(JVM_ClassDepth)(Thread*, jstring)
+{
+  abort();
+}
 
-extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_ClassLoaderDepth)(Thread*) { abort(); }
+extern "C" AVIAN_EXPORT jint JNICALL EXPORT(JVM_ClassLoaderDepth)(Thread*)
+{
+  abort();
+}
 
-uint64_t
-jvmGetSystemPackage(Thread* t, uintptr_t* arguments)
+uint64_t jvmGetSystemPackage(Thread* t, uintptr_t* arguments)
 {
   jstring s = reinterpret_cast<jstring>(arguments[0]);
 
@@ -3632,15 +3822,14 @@ jvmGetSystemPackage(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jstring JNICALL
-EXPORT(JVM_GetSystemPackage)(Thread* t, jstring s)
+    EXPORT(JVM_GetSystemPackage)(Thread* t, jstring s)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(s) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(s)};
 
   return reinterpret_cast<jstring>(run(t, jvmGetSystemPackage, arguments));
 }
 
-uint64_t
-jvmGetSystemPackages(Thread* t, uintptr_t*)
+uint64_t jvmGetSystemPackages(Thread* t, uintptr_t*)
 {
   return reinterpret_cast<uintptr_t>(makeLocalReference(
       t,
@@ -3649,31 +3838,36 @@ jvmGetSystemPackages(Thread* t, uintptr_t*)
 }
 
 extern "C" AVIAN_EXPORT jobjectArray JNICALL
-EXPORT(JVM_GetSystemPackages)(Thread* t)
+    EXPORT(JVM_GetSystemPackages)(Thread* t)
 {
   return reinterpret_cast<jobjectArray>(run(t, jvmGetSystemPackages, 0));
 }
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_AllocateNewObject)(Thread*, jobject, jclass,
-                      jclass) { abort(); }
+    EXPORT(JVM_AllocateNewObject)(Thread*, jobject, jclass, jclass)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_AllocateNewArray)(Thread*, jobject, jclass,
-                     jint) { abort(); }
+    EXPORT(JVM_AllocateNewArray)(Thread*, jobject, jclass, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_LatestUserDefinedLoader)(Thread* t)
+    EXPORT(JVM_LatestUserDefinedLoader)(Thread* t)
 {
   ENTER(t, Thread::ActiveState);
 
-  class Visitor: public Processor::StackVisitor {
+  class Visitor : public Processor::StackVisitor {
    public:
-    Visitor(Thread* t):
-      t(t), loader(0)
-    { }
+    Visitor(Thread* t) : t(t), loader(0)
+    {
+    }
 
-    virtual bool visit(Processor::StackWalker* walker) {
+    virtual bool visit(Processor::StackWalker* walker)
+    {
       GcClassLoader* loader = walker->method()->class_()->loader();
       if (loader and loader != roots(t)->bootLoader()
           and strcmp(objectClass(t, loader)->name()->body().begin(),
@@ -3696,81 +3890,84 @@ EXPORT(JVM_LatestUserDefinedLoader)(Thread* t)
 }
 
 extern "C" AVIAN_EXPORT jclass JNICALL
-EXPORT(JVM_LoadClass0)(Thread*, jobject, jclass,
-               jstring) { abort(); }
+    EXPORT(JVM_LoadClass0)(Thread*, jobject, jclass, jstring)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetArrayLength)(Thread* t, jobject array)
+    EXPORT(JVM_GetArrayLength)(Thread* t, jobject array)
 {
   ENTER(t, Thread::ActiveState);
 
   return fieldAtOffset<uintptr_t>(*array, BytesPerWord);
 }
 
-uint64_t
-jvmGetArrayElement(Thread* t, uintptr_t* arguments)
+uint64_t jvmGetArrayElement(Thread* t, uintptr_t* arguments)
 {
   jobject array = reinterpret_cast<jobject>(arguments[0]);
   jint index = arguments[1];
 
   switch (objectClass(t, *array)->name()->body()[1]) {
   case 'Z':
-    return reinterpret_cast<intptr_t>
-      (makeLocalReference
-       (t, makeBoolean(t, fieldAtOffset<int8_t>(*array, ArrayBody + index))));
+    return reinterpret_cast<intptr_t>(makeLocalReference(
+        t, makeBoolean(t, fieldAtOffset<int8_t>(*array, ArrayBody + index))));
   case 'B':
-    return reinterpret_cast<intptr_t>
-      (makeLocalReference
-       (t, makeByte(t, fieldAtOffset<int8_t>(*array, ArrayBody + index))));
+    return reinterpret_cast<intptr_t>(makeLocalReference(
+        t, makeByte(t, fieldAtOffset<int8_t>(*array, ArrayBody + index))));
   case 'C':
-    return reinterpret_cast<intptr_t>
-      (makeLocalReference
-       (t, makeChar(t, fieldAtOffset<int16_t>(*array, ArrayBody + (index * 2)))));
+    return reinterpret_cast<intptr_t>(makeLocalReference(
+        t,
+        makeChar(t, fieldAtOffset<int16_t>(*array, ArrayBody + (index * 2)))));
   case 'S':
-    return reinterpret_cast<intptr_t>
-      (makeLocalReference
-       (t, makeShort(t, fieldAtOffset<int16_t>(*array, ArrayBody + (index * 2)))));
+    return reinterpret_cast<intptr_t>(makeLocalReference(
+        t,
+        makeShort(t, fieldAtOffset<int16_t>(*array, ArrayBody + (index * 2)))));
   case 'I':
-    return reinterpret_cast<intptr_t>
-      (makeLocalReference
-       (t, makeInt(t, fieldAtOffset<int32_t>(*array, ArrayBody + (index * 4)))));
+    return reinterpret_cast<intptr_t>(makeLocalReference(
+        t,
+        makeInt(t, fieldAtOffset<int32_t>(*array, ArrayBody + (index * 4)))));
   case 'F':
-    return reinterpret_cast<intptr_t>
-      (makeLocalReference
-       (t, makeFloat(t, fieldAtOffset<int32_t>(*array, ArrayBody + (index * 4)))));
+    return reinterpret_cast<intptr_t>(makeLocalReference(
+        t,
+        makeFloat(t, fieldAtOffset<int32_t>(*array, ArrayBody + (index * 4)))));
   case 'J':
-    return reinterpret_cast<intptr_t>
-      (makeLocalReference
-       (t, makeLong(t, fieldAtOffset<int64_t>(*array, ArrayBody + (index * 8)))));
+    return reinterpret_cast<intptr_t>(makeLocalReference(
+        t,
+        makeLong(t, fieldAtOffset<int64_t>(*array, ArrayBody + (index * 8)))));
   case 'D':
-    return reinterpret_cast<intptr_t>
-      (makeLocalReference
-       (t, makeDouble(t, fieldAtOffset<int64_t>(*array, ArrayBody + (index * 8)))));
+    return reinterpret_cast<intptr_t>(makeLocalReference(
+        t,
+        makeDouble(t,
+                   fieldAtOffset<int64_t>(*array, ArrayBody + (index * 8)))));
   case 'L':
   case '[':
-    return reinterpret_cast<intptr_t>
-      (makeLocalReference
-       (t, fieldAtOffset<object>(*array, ArrayBody + (index * BytesPerWord))));
+    return reinterpret_cast<intptr_t>(makeLocalReference(
+        t, fieldAtOffset<object>(*array, ArrayBody + (index * BytesPerWord))));
   default:
     abort(t);
   }
 }
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_GetArrayElement)(Thread* t, jobject array, jint index)
+    EXPORT(JVM_GetArrayElement)(Thread* t, jobject array, jint index)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(array),
-                            static_cast<uintptr_t>(index) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(array), static_cast<uintptr_t>(index)};
 
   return reinterpret_cast<jobject>(run(t, jvmGetArrayElement, arguments));
 }
 
 extern "C" AVIAN_EXPORT jvalue JNICALL
-EXPORT(JVM_GetPrimitiveArrayElement)(Thread*, jobject, jint, jint) { abort(); }
+    EXPORT(JVM_GetPrimitiveArrayElement)(Thread*, jobject, jint, jint)
+{
+  abort();
+}
 
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_SetArrayElement)(Thread* t, jobject array, jint index,
-                            jobject value)
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(JVM_SetArrayElement)(Thread* t,
+                                                                 jobject array,
+                                                                 jint index,
+                                                                 jobject value)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3817,9 +4014,11 @@ EXPORT(JVM_SetArrayElement)(Thread* t, jobject array, jint index,
   }
 }
 
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_SetPrimitiveArrayElement)(Thread*, jobject, jint, jvalue,
-                             unsigned char) { abort(); }
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(
+    JVM_SetPrimitiveArrayElement)(Thread*, jobject, jint, jvalue, unsigned char)
+{
+  abort();
+}
 
 object makeNewArray(Thread* t, GcClass* c, unsigned length)
 {
@@ -3834,21 +4033,27 @@ object makeNewArray(Thread* t, GcClass* c, unsigned length)
       } else {
         return makeByteArray(t, length);
       }
-    case 'c': return makeCharArray(t, length);
-    case 'd': return makeDoubleArray(t, length);
-    case 'f': return makeFloatArray(t, length);
-    case 'i': return makeIntArray(t, length);
-    case 'l': return makeLongArray(t, length);
-    case 's': return makeShortArray(t, length);
-    default: abort(t);
+    case 'c':
+      return makeCharArray(t, length);
+    case 'd':
+      return makeDoubleArray(t, length);
+    case 'f':
+      return makeFloatArray(t, length);
+    case 'i':
+      return makeIntArray(t, length);
+    case 'l':
+      return makeLongArray(t, length);
+    case 's':
+      return makeShortArray(t, length);
+    default:
+      abort(t);
     }
   } else {
     return makeObjectArray(t, c, length);
   }
 }
 
-uint64_t
-jvmNewArray(Thread* t, uintptr_t* arguments)
+uint64_t jvmNewArray(Thread* t, uintptr_t* arguments)
 {
   jclass elementClass = reinterpret_cast<jclass>(arguments[0]);
   jint length = arguments[1];
@@ -3858,16 +4063,15 @@ jvmNewArray(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_NewArray)(Thread* t, jclass elementClass, jint length)
+    EXPORT(JVM_NewArray)(Thread* t, jclass elementClass, jint length)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(elementClass),
-                            static_cast<uintptr_t>(length) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(elementClass),
+                           static_cast<uintptr_t>(length)};
 
   return reinterpret_cast<jobject>(run(t, jvmNewArray, arguments));
 }
 
-uint64_t
-jvmNewMultiArray(Thread* t, uintptr_t* arguments)
+uint64_t jvmNewMultiArray(Thread* t, uintptr_t* arguments)
 {
   jclass elementClass = reinterpret_cast<jclass>(arguments[0]);
   jintArray dimensions = reinterpret_cast<jintArray>(arguments[1]);
@@ -3895,17 +4099,18 @@ jvmNewMultiArray(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_NewMultiArray)(Thread* t, jclass elementClass,
-                          jintArray dimensions)
+    EXPORT(JVM_NewMultiArray)(Thread* t,
+                              jclass elementClass,
+                              jintArray dimensions)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(elementClass),
-                            reinterpret_cast<uintptr_t>(dimensions) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(elementClass),
+                           reinterpret_cast<uintptr_t>(dimensions)};
 
   return reinterpret_cast<jobject>(run(t, jvmNewMultiArray, arguments));
 }
 
 extern "C" AVIAN_EXPORT jclass JNICALL
-EXPORT(JVM_GetCallerClass)(Thread* t, int target)
+    EXPORT(JVM_GetCallerClass)(Thread* t, int target)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3917,7 +4122,7 @@ EXPORT(JVM_GetCallerClass)(Thread* t, int target)
 }
 
 extern "C" AVIAN_EXPORT jclass JNICALL
-EXPORT(JVM_FindPrimitiveClass)(Thread* t, const char* name)
+    EXPORT(JVM_FindPrimitiveClass)(Thread* t, const char* name)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3956,8 +4161,7 @@ EXPORT(JVM_FindPrimitiveClass)(Thread* t, const char* name)
   }
 }
 
-uint64_t
-jvmResolveClass(Thread* t, uintptr_t* arguments)
+uint64_t jvmResolveClass(Thread* t, uintptr_t* arguments)
 {
   jclass c = reinterpret_cast<jclass>(arguments[0]);
 
@@ -3970,15 +4174,14 @@ jvmResolveClass(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_ResolveClass)(Thread* t, jclass c)
+    EXPORT(JVM_ResolveClass)(Thread* t, jclass c)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c)};
 
   run(t, jvmResolveClass, arguments);
 }
 
-uint64_t
-jvmFindClassFromClassLoader(Thread* t, uintptr_t* arguments)
+uint64_t jvmFindClassFromClassLoader(Thread* t, uintptr_t* arguments)
 {
   const char* name = reinterpret_cast<const char*>(arguments[0]);
   jboolean init = arguments[1];
@@ -4003,31 +4206,34 @@ jvmFindClassFromClassLoader(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jclass JNICALL
-EXPORT(JVM_FindClassFromClassLoader)(Thread* t, const char* name,
-                                     jboolean init, jobject loader,
-                                     jboolean throwError)
+    EXPORT(JVM_FindClassFromClassLoader)(Thread* t,
+                                         const char* name,
+                                         jboolean init,
+                                         jobject loader,
+                                         jboolean throwError)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(name),
-                            init,
-                            reinterpret_cast<uintptr_t>(loader),
-                            throwError };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(name),
+                           init,
+                           reinterpret_cast<uintptr_t>(loader),
+                           throwError};
 
-  return reinterpret_cast<jclass>
-    (run(t, jvmFindClassFromClassLoader, arguments));
+  return reinterpret_cast<jclass>(
+      run(t, jvmFindClassFromClassLoader, arguments));
 }
 
 extern "C" AVIAN_EXPORT jclass JNICALL
-JVM_FindClassFromBootLoader(Thread* t, const char* name)
+    JVM_FindClassFromBootLoader(Thread* t, const char* name)
 {
   return EXPORT(JVM_FindClassFromClassLoader)(t, name, false, 0, false);
 }
 
 extern "C" AVIAN_EXPORT jclass JNICALL
-EXPORT(JVM_FindClassFromClass)(Thread*, const char*, jboolean, jclass)
-{ abort(); }
+    EXPORT(JVM_FindClassFromClass)(Thread*, const char*, jboolean, jclass)
+{
+  abort();
+}
 
-uint64_t
-jvmFindLoadedClass(Thread* t, uintptr_t* arguments)
+uint64_t jvmFindLoadedClass(Thread* t, uintptr_t* arguments)
 {
   jobject loader = reinterpret_cast<jobject>(arguments[0]);
   jstring name = reinterpret_cast<jstring>(arguments[1]);
@@ -4042,21 +4248,20 @@ jvmFindLoadedClass(Thread* t, uintptr_t* arguments)
 
   GcClass* c = findLoadedClass(t, cast<GcClassLoader>(t, *loader), spec);
 
-  return reinterpret_cast<uint64_t>
-    (c ? makeLocalReference(t, getJClass(t, c)) : 0);
+  return reinterpret_cast<uint64_t>(c ? makeLocalReference(t, getJClass(t, c))
+                                      : 0);
 }
 
 extern "C" AVIAN_EXPORT jclass JNICALL
-EXPORT(JVM_FindLoadedClass)(Thread* t, jobject loader, jstring name)
+    EXPORT(JVM_FindLoadedClass)(Thread* t, jobject loader, jstring name)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(loader),
-                            reinterpret_cast<uintptr_t>(name) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(loader),
+                           reinterpret_cast<uintptr_t>(name)};
 
   return reinterpret_cast<jclass>(run(t, jvmFindLoadedClass, arguments));
 }
 
-uint64_t
-jvmDefineClass(Thread* t, uintptr_t* arguments)
+uint64_t jvmDefineClass(Thread* t, uintptr_t* arguments)
 {
   jobject loader = reinterpret_cast<jobject>(arguments[0]);
   const uint8_t* data = reinterpret_cast<const uint8_t*>(arguments[1]);
@@ -4072,42 +4277,54 @@ jvmDefineClass(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jclass JNICALL
-EXPORT(JVM_DefineClass)(Thread* t, const char*, jobject loader,
-                        const uint8_t* data, jsize length, jobject)
+    EXPORT(JVM_DefineClass)(Thread* t,
+                            const char*,
+                            jobject loader,
+                            const uint8_t* data,
+                            jsize length,
+                            jobject)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(loader),
-                            reinterpret_cast<uintptr_t>(data),
-                            static_cast<uintptr_t>(length) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(loader),
+                           reinterpret_cast<uintptr_t>(data),
+                           static_cast<uintptr_t>(length)};
 
   return reinterpret_cast<jclass>(run(t, jvmDefineClass, arguments));
 }
 
 extern "C" AVIAN_EXPORT jclass JNICALL
-EXPORT(JVM_DefineClassWithSource)(Thread* t, const char*, jobject loader,
-                          const uint8_t* data, jsize length, jobject,
-                          const char*)
+    EXPORT(JVM_DefineClassWithSource)(Thread* t,
+                                      const char*,
+                                      jobject loader,
+                                      const uint8_t* data,
+                                      jsize length,
+                                      jobject,
+                                      const char*)
 {
   return EXPORT(JVM_DefineClass)(t, 0, loader, data, length, 0);
 }
 
 extern "C" AVIAN_EXPORT jclass JNICALL
-EXPORT(JVM_DefineClassWithSourceCond)(Thread* t, const char*, jobject loader,
-                                      const uint8_t* data, jsize length,
-                                      jobject, const char*, jboolean)
+    EXPORT(JVM_DefineClassWithSourceCond)(Thread* t,
+                                          const char*,
+                                          jobject loader,
+                                          const uint8_t* data,
+                                          jsize length,
+                                          jobject,
+                                          const char*,
+                                          jboolean)
 {
   return EXPORT(JVM_DefineClass)(t, 0, loader, data, length, 0);
 }
 
 extern "C" AVIAN_EXPORT jstring JNICALL
-EXPORT(JVM_GetClassName)(Thread* t, jclass c)
+    EXPORT(JVM_GetClassName)(Thread* t, jclass c)
 {
   ENTER(t, Thread::ActiveState);
 
   return reinterpret_cast<jstring>(makeLocalReference(t, (*c)->name()));
 }
 
-uint64_t
-jvmGetClassInterfaces(Thread* t, uintptr_t* arguments)
+uint64_t jvmGetClassInterfaces(Thread* t, uintptr_t* arguments)
 {
   jclass c = reinterpret_cast<jclass>(arguments[0]);
 
@@ -4135,16 +4352,16 @@ jvmGetClassInterfaces(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jobjectArray JNICALL
-EXPORT(JVM_GetClassInterfaces)(Thread* t, jclass c)
+    EXPORT(JVM_GetClassInterfaces)(Thread* t, jclass c)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c)};
 
   return reinterpret_cast<jobjectArray>(
       run(t, jvmGetClassInterfaces, arguments));
 }
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_GetClassLoader)(Thread* t, jclass c)
+    EXPORT(JVM_GetClassLoader)(Thread* t, jclass c)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -4169,7 +4386,7 @@ EXPORT(JVM_GetClassLoader)(Thread* t, jclass c)
 }
 
 extern "C" AVIAN_EXPORT jboolean JNICALL
-EXPORT(JVM_IsInterface)(Thread* t, jclass c)
+    EXPORT(JVM_IsInterface)(Thread* t, jclass c)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -4177,7 +4394,7 @@ EXPORT(JVM_IsInterface)(Thread* t, jclass c)
 }
 
 extern "C" AVIAN_EXPORT jobjectArray JNICALL
-EXPORT(JVM_GetClassSigners)(Thread* t, jclass c)
+    EXPORT(JVM_GetClassSigners)(Thread* t, jclass c)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -4190,25 +4407,25 @@ EXPORT(JVM_GetClassSigners)(Thread* t, jclass c)
 }
 
 extern "C" AVIAN_EXPORT jbyteArray JNICALL
-EXPORT(JVM_GetClassTypeAnnotations)(Thread*, jclass)
+    EXPORT(JVM_GetClassTypeAnnotations)(Thread*, jclass)
 {
   abort();
 }
 
 extern "C" AVIAN_EXPORT jbyteArray JNICALL
-EXPORT(JVM_GetFieldTypeAnnotations)(Thread*, jobject)
+    EXPORT(JVM_GetFieldTypeAnnotations)(Thread*, jobject)
 {
   abort();
 }
 
 extern "C" AVIAN_EXPORT jbyteArray JNICALL
-EXPORT(JVM_GetMethodTypeAnnotations)(Thread*, jobject)
+    EXPORT(JVM_GetMethodTypeAnnotations)(Thread*, jobject)
 {
   abort();
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_SetClassSigners)(Thread* t, jclass c, jobjectArray signers)
+    EXPORT(JVM_SetClassSigners)(Thread* t, jclass c, jobjectArray signers)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -4217,8 +4434,7 @@ EXPORT(JVM_SetClassSigners)(Thread* t, jclass c, jobjectArray signers)
   runtimeData->setSigners(t, reinterpret_cast<object>(*signers));
 }
 
-uint64_t
-jvmGetProtectionDomain(Thread* t, uintptr_t* arguments)
+uint64_t jvmGetProtectionDomain(Thread* t, uintptr_t* arguments)
 {
   jclass c = reinterpret_cast<jclass>(arguments[0]);
 
@@ -4234,18 +4450,21 @@ jvmGetProtectionDomain(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_GetProtectionDomain)(Thread* t, jclass c)
+    EXPORT(JVM_GetProtectionDomain)(Thread* t, jclass c)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c)};
 
   return reinterpret_cast<jobject>(run(t, jvmGetProtectionDomain, arguments));
 }
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_SetProtectionDomain)(Thread*, jclass, jobject) { abort(); }
+    EXPORT(JVM_SetProtectionDomain)(Thread*, jclass, jobject)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jboolean JNICALL
-EXPORT(JVM_IsArrayClass)(Thread* t, jclass c)
+    EXPORT(JVM_IsArrayClass)(Thread* t, jclass c)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -4253,23 +4472,22 @@ EXPORT(JVM_IsArrayClass)(Thread* t, jclass c)
 }
 
 extern "C" AVIAN_EXPORT jboolean JNICALL
-EXPORT(JVM_IsPrimitiveClass)(Thread* t, jclass c)
+    EXPORT(JVM_IsPrimitiveClass)(Thread* t, jclass c)
 {
   ENTER(t, Thread::ActiveState);
 
   return ((*c)->vmClass()->vmFlags() & PrimitiveFlag) != 0;
 }
 
-uint64_t
-jvmGetComponentType(Thread* t, uintptr_t* arguments)
+uint64_t jvmGetComponentType(Thread* t, uintptr_t* arguments)
 {
   jclass c = reinterpret_cast<jclass>(arguments[0]);
 
   if ((*c)->vmClass()->arrayDimensions()) {
     uint8_t n = (*c)->vmClass()->name()->body()[1];
     if (n != 'L' and n != '[') {
-      return reinterpret_cast<uintptr_t>
-        (makeLocalReference(t, getJClass(t, primitiveClass(t, n))));
+      return reinterpret_cast<uintptr_t>(
+          makeLocalReference(t, getJClass(t, primitiveClass(t, n))));
     } else {
       return reinterpret_cast<uintptr_t>(makeLocalReference(
           t, getJClass(t, (*c)->vmClass()->arrayElementClass())));
@@ -4280,15 +4498,14 @@ jvmGetComponentType(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jclass JNICALL
-EXPORT(JVM_GetComponentType)(Thread* t, jclass c)
+    EXPORT(JVM_GetComponentType)(Thread* t, jclass c)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c)};
 
   return reinterpret_cast<jclass>(run(t, jvmGetComponentType, arguments));
 }
 
-uint64_t
-jvmGetClassModifiers(Thread* t, uintptr_t* arguments)
+uint64_t jvmGetClassModifiers(Thread* t, uintptr_t* arguments)
 {
   return classModifiers(
       t,
@@ -4296,15 +4513,14 @@ jvmGetClassModifiers(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetClassModifiers)(Thread* t, jclass c)
+    EXPORT(JVM_GetClassModifiers)(Thread* t, jclass c)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c)};
 
   return run(t, jvmGetClassModifiers, arguments);
 }
 
-uint64_t
-jvmGetDeclaredClasses(Thread* t, uintptr_t* arguments)
+uint64_t jvmGetDeclaredClasses(Thread* t, uintptr_t* arguments)
 {
   return reinterpret_cast<uintptr_t>(makeLocalReference(
       t,
@@ -4316,16 +4532,15 @@ jvmGetDeclaredClasses(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jobjectArray JNICALL
-EXPORT(JVM_GetDeclaredClasses)(Thread* t, jclass c)
+    EXPORT(JVM_GetDeclaredClasses)(Thread* t, jclass c)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c)};
 
   return reinterpret_cast<jobjectArray>(
       run(t, jvmGetDeclaredClasses, arguments));
 }
 
-uint64_t
-jvmGetDeclaringClass(Thread* t, uintptr_t* arguments)
+uint64_t jvmGetDeclaringClass(Thread* t, uintptr_t* arguments)
 {
   return reinterpret_cast<uintptr_t>(makeLocalReference(
       t,
@@ -4336,15 +4551,14 @@ jvmGetDeclaringClass(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jclass JNICALL
-EXPORT(JVM_GetDeclaringClass)(Thread* t, jclass c)
+    EXPORT(JVM_GetDeclaringClass)(Thread* t, jclass c)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c)};
 
   return reinterpret_cast<jclass>(run(t, jvmGetDeclaringClass, arguments));
 }
 
-uint64_t
-jvmGetClassSignature(Thread* t, uintptr_t* arguments)
+uint64_t jvmGetClassSignature(Thread* t, uintptr_t* arguments)
 {
   jclass c = reinterpret_cast<jclass>(arguments[0]);
 
@@ -4362,15 +4576,15 @@ jvmGetClassSignature(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jstring JNICALL
-EXPORT(JVM_GetClassSignature)(Thread* t, jclass c)
+    EXPORT(JVM_GetClassSignature)(Thread* t, jclass c)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c)};
 
   return reinterpret_cast<jstring>(run(t, jvmGetClassSignature, arguments));
 }
 
 extern "C" AVIAN_EXPORT jbyteArray JNICALL
-EXPORT(JVM_GetClassAnnotations)(Thread* t, jclass c)
+    EXPORT(JVM_GetClassAnnotations)(Thread* t, jclass c)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -4380,8 +4594,7 @@ EXPORT(JVM_GetClassAnnotations)(Thread* t, jclass c)
                   : 0;
 }
 
-uint64_t
-jvmGetClassDeclaredMethods(Thread* t, uintptr_t* arguments)
+uint64_t jvmGetClassDeclaredMethods(Thread* t, uintptr_t* arguments)
 {
   jclass c = reinterpret_cast<jclass>(arguments[0]);
   jboolean publicOnly = arguments[1];
@@ -4421,16 +4634,17 @@ jvmGetClassDeclaredMethods(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jobjectArray JNICALL
-EXPORT(JVM_GetClassDeclaredMethods)(Thread* t, jclass c, jboolean publicOnly)
+    EXPORT(JVM_GetClassDeclaredMethods)(Thread* t,
+                                        jclass c,
+                                        jboolean publicOnly)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c), publicOnly };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c), publicOnly};
 
-  return reinterpret_cast<jobjectArray>
-    (run(t, jvmGetClassDeclaredMethods, arguments));
+  return reinterpret_cast<jobjectArray>(
+      run(t, jvmGetClassDeclaredMethods, arguments));
 }
 
-uint64_t
-jvmGetClassDeclaredFields(Thread* t, uintptr_t* arguments)
+uint64_t jvmGetClassDeclaredFields(Thread* t, uintptr_t* arguments)
 {
   jclass c = reinterpret_cast<jclass>(arguments[0]);
   jboolean publicOnly = arguments[1];
@@ -4467,16 +4681,15 @@ jvmGetClassDeclaredFields(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jobjectArray JNICALL
-EXPORT(JVM_GetClassDeclaredFields)(Thread* t, jclass c, jboolean publicOnly)
+    EXPORT(JVM_GetClassDeclaredFields)(Thread* t, jclass c, jboolean publicOnly)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c), publicOnly };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c), publicOnly};
 
-  return reinterpret_cast<jobjectArray>
-    (run(t, jvmGetClassDeclaredFields, arguments));
+  return reinterpret_cast<jobjectArray>(
+      run(t, jvmGetClassDeclaredFields, arguments));
 }
 
-uint64_t
-jvmGetClassDeclaredConstructors(Thread* t, uintptr_t* arguments)
+uint64_t jvmGetClassDeclaredConstructors(Thread* t, uintptr_t* arguments)
 {
   jclass c = reinterpret_cast<jclass>(arguments[0]);
   jboolean publicOnly = arguments[1];
@@ -4517,25 +4730,25 @@ jvmGetClassDeclaredConstructors(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jobjectArray JNICALL
-EXPORT(JVM_GetClassDeclaredConstructors)(Thread* t, jclass c,
-                                         jboolean publicOnly)
+    EXPORT(JVM_GetClassDeclaredConstructors)(Thread* t,
+                                             jclass c,
+                                             jboolean publicOnly)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c), publicOnly };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c), publicOnly};
 
-  return reinterpret_cast<jobjectArray>
-    (run(t, jvmGetClassDeclaredConstructors, arguments));
+  return reinterpret_cast<jobjectArray>(
+      run(t, jvmGetClassDeclaredConstructors, arguments));
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetClassAccessFlags)(Thread* t, jclass c)
+    EXPORT(JVM_GetClassAccessFlags)(Thread* t, jclass c)
 {
   ENTER(t, Thread::ActiveState);
 
   return (*c)->vmClass()->flags();
 }
 
-uint64_t
-jvmInvokeMethod(Thread* t, uintptr_t* arguments)
+uint64_t jvmInvokeMethod(Thread* t, uintptr_t* arguments)
 {
   jobject method = reinterpret_cast<jobject>(arguments[0]);
   jobject instance = reinterpret_cast<jobject>(arguments[1]);
@@ -4564,18 +4777,19 @@ jvmInvokeMethod(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_InvokeMethod)(Thread* t, jobject method, jobject instance,
-                         jobjectArray args)
+    EXPORT(JVM_InvokeMethod)(Thread* t,
+                             jobject method,
+                             jobject instance,
+                             jobjectArray args)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(method),
-                            reinterpret_cast<uintptr_t>(instance),
-                            reinterpret_cast<uintptr_t>(args) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(method),
+                           reinterpret_cast<uintptr_t>(instance),
+                           reinterpret_cast<uintptr_t>(args)};
 
   return reinterpret_cast<jobject>(run(t, jvmInvokeMethod, arguments));
 }
 
-uint64_t
-jvmNewInstanceFromConstructor(Thread* t, uintptr_t* arguments)
+uint64_t jvmNewInstanceFromConstructor(Thread* t, uintptr_t* arguments)
 {
   jobject constructor = reinterpret_cast<jobject>(arguments[0]);
   jobjectArray args = reinterpret_cast<jobjectArray>(arguments[1]);
@@ -4599,18 +4813,19 @@ jvmNewInstanceFromConstructor(Thread* t, uintptr_t* arguments)
 }
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_NewInstanceFromConstructor)(Thread* t, jobject constructor,
-                                       jobjectArray args)
+    EXPORT(JVM_NewInstanceFromConstructor)(Thread* t,
+                                           jobject constructor,
+                                           jobjectArray args)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(constructor),
-                            reinterpret_cast<uintptr_t>(args) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(constructor),
+                           reinterpret_cast<uintptr_t>(args)};
 
-  return reinterpret_cast<jobject>
-    (run(t, jvmNewInstanceFromConstructor, arguments));
+  return reinterpret_cast<jobject>(
+      run(t, jvmNewInstanceFromConstructor, arguments));
 }
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_GetClassConstantPool)(Thread* t, jclass c)
+    EXPORT(JVM_GetClassConstantPool)(Thread* t, jclass c)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -4631,9 +4846,10 @@ EXPORT(JVM_GetClassConstantPool)(Thread* t, jclass c)
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_ConstantPoolGetSize)(Thread* t, jobject, jobject pool)
+    EXPORT(JVM_ConstantPoolGetSize)(Thread* t, jobject, jobject pool)
 {
-  if (pool == 0) return 0;
+  if (pool == 0)
+    return 0;
 
   ENTER(t, Thread::ActiveState);
 
@@ -4641,43 +4857,57 @@ EXPORT(JVM_ConstantPoolGetSize)(Thread* t, jobject, jobject pool)
 }
 
 extern "C" AVIAN_EXPORT jclass JNICALL
-EXPORT(JVM_ConstantPoolGetClassAt)(Thread*, jobject, jobject, jint)
-{ abort(); }
+    EXPORT(JVM_ConstantPoolGetClassAt)(Thread*, jobject, jobject, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jclass JNICALL
-EXPORT(JVM_ConstantPoolGetClassAtIfLoaded)(Thread*, jobject, jobject, jint)
-{ abort(); }
+    EXPORT(JVM_ConstantPoolGetClassAtIfLoaded)(Thread*, jobject, jobject, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_ConstantPoolGetMethodAt)(Thread*, jobject, jobject, jint)
-{ abort(); }
+    EXPORT(JVM_ConstantPoolGetMethodAt)(Thread*, jobject, jobject, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_ConstantPoolGetMethodAtIfLoaded)(Thread*, jobject, jobject, jint)
-{ abort(); }
+    EXPORT(JVM_ConstantPoolGetMethodAtIfLoaded)(Thread*, jobject, jobject, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_ConstantPoolGetFieldAt)(Thread*, jobject, jobject, jint)
-{ abort(); }
+    EXPORT(JVM_ConstantPoolGetFieldAt)(Thread*, jobject, jobject, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_ConstantPoolGetFieldAtIfLoaded)(Thread*, jobject, jobject, jint)
-{ abort(); }
+    EXPORT(JVM_ConstantPoolGetFieldAtIfLoaded)(Thread*, jobject, jobject, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jobjectArray JNICALL
-EXPORT(JVM_ConstantPoolGetMemberRefInfoAt)(Thread*, jobject, jobject, jint)
-{ abort(); }
+    EXPORT(JVM_ConstantPoolGetMemberRefInfoAt)(Thread*, jobject, jobject, jint)
+{
+  abort();
+}
 
-extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_ConstantPoolGetIntAt)(Thread* t, jobject, jobject pool, jint index)
+extern "C" AVIAN_EXPORT jint JNICALL EXPORT(
+    JVM_ConstantPoolGetIntAt)(Thread* t, jobject, jobject pool, jint index)
 {
   ENTER(t, Thread::ActiveState);
 
   return singletonValue(t, cast<GcSingleton>(t, *pool), index - 1);
 }
 
-extern "C" AVIAN_EXPORT jlong JNICALL
-EXPORT(JVM_ConstantPoolGetLongAt)(Thread* t, jobject, jobject pool, jint index)
+extern "C" AVIAN_EXPORT jlong JNICALL EXPORT(
+    JVM_ConstantPoolGetLongAt)(Thread* t, jobject, jobject pool, jint index)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -4687,18 +4917,16 @@ EXPORT(JVM_ConstantPoolGetLongAt)(Thread* t, jobject, jobject pool, jint index)
   return v;
 }
 
-extern "C" AVIAN_EXPORT jfloat JNICALL
-EXPORT(JVM_ConstantPoolGetFloatAt)(Thread* t, jobject, jobject pool,
-                                   jint index)
+extern "C" AVIAN_EXPORT jfloat JNICALL EXPORT(
+    JVM_ConstantPoolGetFloatAt)(Thread* t, jobject, jobject pool, jint index)
 {
   ENTER(t, Thread::ActiveState);
 
   return bitsToFloat(singletonValue(t, cast<GcSingleton>(t, *pool), index - 1));
 }
 
-extern "C" AVIAN_EXPORT jdouble JNICALL
-EXPORT(JVM_ConstantPoolGetDoubleAt)(Thread* t, jobject, jobject pool,
-                                    jint index)
+extern "C" AVIAN_EXPORT jdouble JNICALL EXPORT(
+    JVM_ConstantPoolGetDoubleAt)(Thread* t, jobject, jobject pool, jint index)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -4709,11 +4937,12 @@ EXPORT(JVM_ConstantPoolGetDoubleAt)(Thread* t, jobject, jobject pool,
 }
 
 extern "C" AVIAN_EXPORT jstring JNICALL
-EXPORT(JVM_ConstantPoolGetStringAt)(Thread*, jobject, jobject, jint)
-{ abort(); }
+    EXPORT(JVM_ConstantPoolGetStringAt)(Thread*, jobject, jobject, jint)
+{
+  abort();
+}
 
-uint64_t
-jvmConstantPoolGetUTF8At(Thread* t, uintptr_t* arguments)
+uint64_t jvmConstantPoolGetUTF8At(Thread* t, uintptr_t* arguments)
 {
   jobject pool = reinterpret_cast<jobject>(arguments[0]);
   jint index = arguments[1];
@@ -4723,24 +4952,22 @@ jvmConstantPoolGetUTF8At(Thread* t, uintptr_t* arguments)
       cast<GcByteArray>(
           t, singletonObject(t, cast<GcSingleton>(t, *pool), index - 1)));
 
-  return reinterpret_cast<uint64_t>
-    (makeLocalReference
-     (t, t->m->classpath->makeString
-      (t, array, 0, fieldAtOffset<uintptr_t>(array, BytesPerWord) - 1)));
+  return reinterpret_cast<uint64_t>(makeLocalReference(
+      t,
+      t->m->classpath->makeString(
+          t, array, 0, fieldAtOffset<uintptr_t>(array, BytesPerWord) - 1)));
 }
 
-extern "C" AVIAN_EXPORT jstring JNICALL
-EXPORT(JVM_ConstantPoolGetUTF8At)(Thread* t, jobject, jobject pool, jint index)
+extern "C" AVIAN_EXPORT jstring JNICALL EXPORT(
+    JVM_ConstantPoolGetUTF8At)(Thread* t, jobject, jobject pool, jint index)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(pool),
-                            static_cast<uintptr_t>(index) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(pool), static_cast<uintptr_t>(index)};
 
-  return reinterpret_cast<jstring>
-    (run(t, jvmConstantPoolGetUTF8At, arguments));
+  return reinterpret_cast<jstring>(run(t, jvmConstantPoolGetUTF8At, arguments));
 }
 
-void
-maybeWrap(Thread* t, bool wrapException)
+void maybeWrap(Thread* t, bool wrapException)
 {
   if (t->exception and wrapException
       and not(instanceOf(t, type(t, GcError::Type), t->exception)
@@ -4761,15 +4988,14 @@ maybeWrap(Thread* t, bool wrapException)
 
     GcThrowable* result = cast<GcThrowable>(t, make(t, paeClass));
     PROTECT(t, result);
-    
+
     t->m->processor->invoke(t, paeConstructor, result, exception);
 
     t->exception = result;
   }
 }
 
-uint64_t
-jvmDoPrivileged(Thread* t, uintptr_t* arguments)
+uint64_t jvmDoPrivileged(Thread* t, uintptr_t* arguments)
 {
   jobject action = reinterpret_cast<jobject>(arguments[0]);
   jboolean wrapException = arguments[1];
@@ -4782,181 +5008,280 @@ jvmDoPrivileged(Thread* t, uintptr_t* arguments)
 
   GcMethod* method;
   if (instanceOf(t, privilegedAction, *action)) {
-    method = resolveMethod
-      (t, privilegedAction, "run", "()Ljava/lang/Object;");
+    method = resolveMethod(t, privilegedAction, "run", "()Ljava/lang/Object;");
   } else {
     GcClass* privilegedExceptionAction = resolveClass(
         t, roots(t)->bootLoader(), "java/security/PrivilegedExceptionAction");
 
-    method = resolveMethod
-      (t, privilegedExceptionAction, "run", "()Ljava/lang/Object;");
+    method = resolveMethod(
+        t, privilegedExceptionAction, "run", "()Ljava/lang/Object;");
   }
 
   THREAD_RESOURCE(t, jboolean, wrapException, maybeWrap(t, wrapException));
 
-  return reinterpret_cast<uint64_t>
-    (makeLocalReference(t, t->m->processor->invoke(t, method, *action)));
+  return reinterpret_cast<uint64_t>(
+      makeLocalReference(t, t->m->processor->invoke(t, method, *action)));
 }
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_DoPrivileged)
-(Thread* t, jclass, jobject action, jobject, jboolean wrapException)
+    EXPORT(JVM_DoPrivileged)(Thread* t,
+                             jclass,
+                             jobject action,
+                             jobject,
+                             jboolean wrapException)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(action),
-                            wrapException };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(action), wrapException};
 
   return reinterpret_cast<jobject>(run(t, jvmDoPrivileged, arguments));
 }
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_GetInheritedAccessControlContext)(Thread*, jclass) { abort(); }
+    EXPORT(JVM_GetInheritedAccessControlContext)(Thread*, jclass)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_GetStackAccessControlContext)(Thread*, jclass)
+    EXPORT(JVM_GetStackAccessControlContext)(Thread*, jclass)
 {
   return 0;
 }
 
-extern "C" AVIAN_EXPORT void* JNICALL
-EXPORT(JVM_RegisterSignal)(jint, void*) { abort(); }
+extern "C" AVIAN_EXPORT void* JNICALL EXPORT(JVM_RegisterSignal)(jint, void*)
+{
+  abort();
+}
 
-extern "C" AVIAN_EXPORT jboolean JNICALL
-EXPORT(JVM_RaiseSignal)(jint) { abort(); }
+extern "C" AVIAN_EXPORT jboolean JNICALL EXPORT(JVM_RaiseSignal)(jint)
+{
+  abort();
+}
 
-extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_FindSignal)(const char*)
+extern "C" AVIAN_EXPORT jint JNICALL EXPORT(JVM_FindSignal)(const char*)
 {
   return -1;
 }
 
 extern "C" AVIAN_EXPORT jboolean JNICALL
-EXPORT(JVM_DesiredAssertionStatus)(Thread*, jclass, jclass)
+    EXPORT(JVM_DesiredAssertionStatus)(Thread*, jclass, jclass)
 {
   return false;
 }
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_AssertionStatusDirectives)(Thread*, jclass) { abort(); }
+    EXPORT(JVM_AssertionStatusDirectives)(Thread*, jclass)
+{
+  abort();
+}
 
-extern "C" AVIAN_EXPORT jboolean JNICALL
-EXPORT(JVM_SupportsCX8)()
+extern "C" AVIAN_EXPORT jboolean JNICALL EXPORT(JVM_SupportsCX8)()
 {
   return true;
 }
 
 extern "C" AVIAN_EXPORT const char* JNICALL
-EXPORT(JVM_GetClassNameUTF)(Thread*, jclass) { abort(); }
+    EXPORT(JVM_GetClassNameUTF)(Thread*, jclass)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_GetClassCPTypes)(Thread*, jclass, unsigned char*) { abort(); }
+    EXPORT(JVM_GetClassCPTypes)(Thread*, jclass, unsigned char*)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetClassCPEntriesCount)(Thread*, jclass) { abort(); }
+    EXPORT(JVM_GetClassCPEntriesCount)(Thread*, jclass)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetClassFieldsCount)(Thread*, jclass) { abort(); }
+    EXPORT(JVM_GetClassFieldsCount)(Thread*, jclass)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetClassMethodsCount)(Thread*, jclass) { abort(); }
+    EXPORT(JVM_GetClassMethodsCount)(Thread*, jclass)
+{
+  abort();
+}
+
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(
+    JVM_GetMethodIxExceptionIndexes)(Thread*, jclass, jint, unsigned short*)
+{
+  abort();
+}
+
+extern "C" AVIAN_EXPORT jint JNICALL
+    EXPORT(JVM_GetMethodIxExceptionsCount)(Thread*, jclass, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_GetMethodIxExceptionIndexes)(Thread*, jclass, jint,
-                                unsigned short*) { abort(); }
+    EXPORT(JVM_GetMethodIxByteCode)(Thread*, jclass, jint, unsigned char*)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetMethodIxExceptionsCount)(Thread*, jclass, jint) { abort(); }
+    EXPORT(JVM_GetMethodIxByteCodeLength)(Thread*, jclass, jint)
+{
+  abort();
+}
 
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_GetMethodIxByteCode)(Thread*, jclass, jint,
-                        unsigned char*) { abort(); }
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(JVM_GetMethodIxExceptionTableEntry)(
+    Thread*,
+    jclass,
+    jint,
+    jint,
+    local::JVM_ExceptionTableEntryType*)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetMethodIxByteCodeLength)(Thread*, jclass, jint) { abort(); }
-
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_GetMethodIxExceptionTableEntry)(Thread*, jclass, jint,
-                                   jint,
-                                   local::JVM_ExceptionTableEntryType*)
-{ abort(); }
+    EXPORT(JVM_GetMethodIxExceptionTableLength)(Thread*, jclass, int)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetMethodIxExceptionTableLength)(Thread*, jclass, int) { abort(); }
+    EXPORT(JVM_GetFieldIxModifiers)(Thread*, jclass, int)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetFieldIxModifiers)(Thread*, jclass, int) { abort(); }
+    EXPORT(JVM_GetMethodIxModifiers)(Thread*, jclass, int)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetMethodIxModifiers)(Thread*, jclass, int) { abort(); }
+    EXPORT(JVM_GetMethodIxLocalsCount)(Thread*, jclass, int)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetMethodIxLocalsCount)(Thread*, jclass, int) { abort(); }
+    EXPORT(JVM_GetMethodIxArgsSize)(Thread*, jclass, int)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetMethodIxArgsSize)(Thread*, jclass, int) { abort(); }
-
-extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetMethodIxMaxStack)(Thread*, jclass, int) { abort(); }
+    EXPORT(JVM_GetMethodIxMaxStack)(Thread*, jclass, int)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jboolean JNICALL
-EXPORT(JVM_IsConstructorIx)(Thread*, jclass, int) { abort(); }
+    EXPORT(JVM_IsConstructorIx)(Thread*, jclass, int)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jboolean JNICALL
-EXPORT(JVM_IsVMGeneratedMethodIx)(Thread*, jclass, int) { abort(); }
+    EXPORT(JVM_IsVMGeneratedMethodIx)(Thread*, jclass, int)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT const char* JNICALL
-EXPORT(JVM_GetMethodIxNameUTF)(Thread*, jclass, jint) { abort(); }
+    EXPORT(JVM_GetMethodIxNameUTF)(Thread*, jclass, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT const char* JNICALL
-EXPORT(JVM_GetMethodIxSignatureUTF)(Thread*, jclass, jint) { abort(); }
+    EXPORT(JVM_GetMethodIxSignatureUTF)(Thread*, jclass, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT const char* JNICALL
-EXPORT(JVM_GetCPFieldNameUTF)(Thread*, jclass, jint) { abort(); }
+    EXPORT(JVM_GetCPFieldNameUTF)(Thread*, jclass, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT const char* JNICALL
-EXPORT(JVM_GetCPMethodNameUTF)(Thread*, jclass, jint) { abort(); }
+    EXPORT(JVM_GetCPMethodNameUTF)(Thread*, jclass, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT const char* JNICALL
-EXPORT(JVM_GetCPMethodSignatureUTF)(Thread*, jclass, jint) { abort(); }
+    EXPORT(JVM_GetCPMethodSignatureUTF)(Thread*, jclass, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT const char* JNICALL
-EXPORT(JVM_GetCPFieldSignatureUTF)(Thread*, jclass, jint) { abort(); }
+    EXPORT(JVM_GetCPFieldSignatureUTF)(Thread*, jclass, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT const char* JNICALL
-EXPORT(JVM_GetCPClassNameUTF)(Thread*, jclass, jint) { abort(); }
+    EXPORT(JVM_GetCPClassNameUTF)(Thread*, jclass, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT const char* JNICALL
-EXPORT(JVM_GetCPFieldClassNameUTF)(Thread*, jclass, jint) { abort(); }
+    EXPORT(JVM_GetCPFieldClassNameUTF)(Thread*, jclass, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT const char* JNICALL
-EXPORT(JVM_GetCPMethodClassNameUTF)(Thread*, jclass, jint) { abort(); }
+    EXPORT(JVM_GetCPMethodClassNameUTF)(Thread*, jclass, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetCPFieldModifiers)(Thread*, jclass, int, jclass) { abort(); }
+    EXPORT(JVM_GetCPFieldModifiers)(Thread*, jclass, int, jclass)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetCPMethodModifiers)(Thread*, jclass, int, jclass) { abort(); }
+    EXPORT(JVM_GetCPMethodModifiers)(Thread*, jclass, int, jclass)
+{
+  abort();
+}
 
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_ReleaseUTF)(const char*) { abort(); }
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(JVM_ReleaseUTF)(const char*)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jboolean JNICALL
-EXPORT(JVM_IsSameClassPackage)(Thread*, jclass, jclass) { abort(); }
+    EXPORT(JVM_IsSameClassPackage)(Thread*, jclass, jclass)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetLastErrorString)(char* dst, int length)
+    EXPORT(JVM_GetLastErrorString)(char* dst, int length)
 {
   strncpy(dst, strerror(errno), length);
   return strlen(dst);
 }
 
-extern "C" AVIAN_EXPORT char* JNICALL
-EXPORT(JVM_NativePath)(char* path)
+extern "C" AVIAN_EXPORT char* JNICALL EXPORT(JVM_NativePath)(char* path)
 {
   return path;
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_Open)(const char* path, jint flags, jint mode)
+    EXPORT(JVM_Open)(const char* path, jint flags, jint mode)
 {
   int r = OPEN(path, flags & 0xFFFF, mode);
   if (r == -1) {
@@ -4966,59 +5291,58 @@ EXPORT(JVM_Open)(const char* path, jint flags, jint mode)
   }
 }
 
-extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_Close)(jint fd)
+extern "C" AVIAN_EXPORT jint JNICALL EXPORT(JVM_Close)(jint fd)
 {
   return CLOSE(fd);
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_Read)(jint fd, char* dst, jint length)
+    EXPORT(JVM_Read)(jint fd, char* dst, jint length)
 {
   return READ(fd, dst, length);
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_Write)(jint fd, char* src, jint length)
+    EXPORT(JVM_Write)(jint fd, char* src, jint length)
 {
   return WRITE(fd, src, length);
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_Available)(jint fd, jlong* result)
+    EXPORT(JVM_Available)(jint fd, jlong* result)
 {
   struct STAT buffer;
   int n;
   if (FSTAT(fd, &buffer) >= 0
-      and (S_ISCHR(buffer.st_mode)
-           or S_ISFIFO(buffer.st_mode)
-           or S_ISSOCK(buffer.st_mode))
-      and local::pipeAvailable(fd, &n))
-  {
+      and (S_ISCHR(buffer.st_mode) or S_ISFIFO(buffer.st_mode)
+           or S_ISSOCK(buffer.st_mode)) and local::pipeAvailable(fd, &n)) {
     *result = n;
     return 1;
   }
 
   int current = LSEEK(fd, 0, SEEK_CUR);
-  if (current == -1) return 0;
+  if (current == -1)
+    return 0;
 
   int end = LSEEK(fd, 0, SEEK_END);
-  if (end == -1) return 0;
+  if (end == -1)
+    return 0;
 
-  if (LSEEK(fd, current, SEEK_SET) == -1) return 0;
+  if (LSEEK(fd, current, SEEK_SET) == -1)
+    return 0;
 
   *result = end - current;
   return 1;
 }
 
 extern "C" AVIAN_EXPORT jlong JNICALL
-EXPORT(JVM_Lseek)(jint fd, jlong offset, jint seek)
+    EXPORT(JVM_Lseek)(jint fd, jlong offset, jint seek)
 {
   return LSEEK(fd, offset, seek);
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_SetLength)(jint fd, jlong length)
+    EXPORT(JVM_SetLength)(jint fd, jlong length)
 {
 #ifdef PLATFORM_WINDOWS
   HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
@@ -5045,8 +5369,7 @@ EXPORT(JVM_SetLength)(jint fd, jlong length)
 #endif
 }
 
-extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_Sync)(jint fd)
+extern "C" AVIAN_EXPORT jint JNICALL EXPORT(JVM_Sync)(jint fd)
 {
 #ifdef PLATFORM_WINDOWS
   HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
@@ -5066,8 +5389,7 @@ EXPORT(JVM_Sync)(jint fd)
 #endif
 }
 
-extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_InitializeSocketLibrary)()
+extern "C" AVIAN_EXPORT jint JNICALL EXPORT(JVM_InitializeSocketLibrary)()
 {
 #ifdef PLATFORM_WINDOWS
   static bool wsaInitialized = false;
@@ -5085,13 +5407,12 @@ EXPORT(JVM_InitializeSocketLibrary)()
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_Socket)(jint domain, jint type, jint protocol)
+    EXPORT(JVM_Socket)(jint domain, jint type, jint protocol)
 {
   return socket(domain, type, protocol);
 }
 
-extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_SocketClose)(jint socket)
+extern "C" AVIAN_EXPORT jint JNICALL EXPORT(JVM_SocketClose)(jint socket)
 {
 #ifdef PLATFORM_WINDOWS
   return closesocket(socket);
@@ -5101,43 +5422,49 @@ EXPORT(JVM_SocketClose)(jint socket)
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_SocketShutdown)(jint socket, jint how)
+    EXPORT(JVM_SocketShutdown)(jint socket, jint how)
 {
   return shutdown(socket, how);
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_Recv)(jint socket, char* dst, jint count, jint flags)
+    EXPORT(JVM_Recv)(jint socket, char* dst, jint count, jint flags)
 {
   return recv(socket, dst, count, flags);
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_Send)(jint socket, char* src, jint count, jint flags)
+    EXPORT(JVM_Send)(jint socket, char* src, jint count, jint flags)
 {
   return send(socket, src, count, flags);
 }
 
-extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_Timeout)(int, long) { abort(); }
+extern "C" AVIAN_EXPORT jint JNICALL EXPORT(JVM_Timeout)(int, long)
+{
+  abort();
+}
 
-extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_Listen)(jint socket, jint count)
+extern "C" AVIAN_EXPORT jint JNICALL EXPORT(JVM_Listen)(jint socket, jint count)
 {
   return listen(socket, count);
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_Connect)(jint socket, sockaddr* address, jint addressLength)
+    EXPORT(JVM_Connect)(jint socket, sockaddr* address, jint addressLength)
 {
   return connect(socket, address, addressLength);
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_Bind)(jint, struct sockaddr*, jint) { abort(); }
+    EXPORT(JVM_Bind)(jint, struct sockaddr*, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_Accept)(jint socket, struct sockaddr* address, jint* addressLength)
+    EXPORT(JVM_Accept)(jint socket,
+                       struct sockaddr* address,
+                       jint* addressLength)
 {
   socklen_t length = *addressLength;
   int r = accept(socket, address, &length);
@@ -5146,15 +5473,19 @@ EXPORT(JVM_Accept)(jint socket, struct sockaddr* address, jint* addressLength)
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_RecvFrom)(jint, char*, int,
-             int, struct sockaddr*, int*) { abort(); }
+    EXPORT(JVM_RecvFrom)(jint, char*, int, int, struct sockaddr*, int*)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_SendTo)(jint, char*, int,
-           int, struct sockaddr*, int) { abort(); }
+    EXPORT(JVM_SendTo)(jint, char*, int, int, struct sockaddr*, int)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_SocketAvailable)(jint socket, jint* count)
+    EXPORT(JVM_SocketAvailable)(jint socket, jint* count)
 {
 #ifdef PLATFORM_WINDOWS
   unsigned long c = *count;
@@ -5167,8 +5498,9 @@ EXPORT(JVM_SocketAvailable)(jint socket, jint* count)
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetSockName)(jint socket, struct sockaddr* address,
-                        int* addressLength)
+    EXPORT(JVM_GetSockName)(jint socket,
+                            struct sockaddr* address,
+                            int* addressLength)
 {
   socklen_t length = *addressLength;
   int r = getsockname(socket, address, &length);
@@ -5176,9 +5508,11 @@ EXPORT(JVM_GetSockName)(jint socket, struct sockaddr* address,
   return r;
 }
 
-extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_GetSockOpt)(jint socket, int level, int optionName,
-                       char* optionValue, int* optionLength)
+extern "C" AVIAN_EXPORT jint JNICALL EXPORT(JVM_GetSockOpt)(jint socket,
+                                                            int level,
+                                                            int optionName,
+                                                            char* optionValue,
+                                                            int* optionLength)
 {
   socklen_t length = *optionLength;
   int rv = getsockopt(socket, level, optionName, optionValue, &length);
@@ -5187,29 +5521,39 @@ EXPORT(JVM_GetSockOpt)(jint socket, int level, int optionName,
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_SetSockOpt)(jint socket, int level, int optionName,
-                       const char* optionValue, int optionLength)
+    EXPORT(JVM_SetSockOpt)(jint socket,
+                           int level,
+                           int optionName,
+                           const char* optionValue,
+                           int optionLength)
 {
   return setsockopt(socket, level, optionName, optionValue, optionLength);
 }
 
 extern "C" AVIAN_EXPORT struct protoent* JNICALL
-EXPORT(JVM_GetProtoByName)(char*) { abort(); }
+    EXPORT(JVM_GetProtoByName)(char*)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT struct hostent* JNICALL
-EXPORT(JVM_GetHostByAddr)(const char*, int, int) { abort(); }
+    EXPORT(JVM_GetHostByAddr)(const char*, int, int)
+{
+  abort();
+}
 
-extern "C" AVIAN_EXPORT struct hostent* JNICALL
-EXPORT(JVM_GetHostByName)(char*) { abort(); }
+extern "C" AVIAN_EXPORT struct hostent* JNICALL EXPORT(JVM_GetHostByName)(char*)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT int JNICALL
-EXPORT(JVM_GetHostName)(char* name, int length)
+    EXPORT(JVM_GetHostName)(char* name, int length)
 {
   return gethostname(name, length);
 }
 
-extern "C" AVIAN_EXPORT void* JNICALL
-EXPORT(JVM_RawMonitorCreate)(void)
+extern "C" AVIAN_EXPORT void* JNICALL EXPORT(JVM_RawMonitorCreate)(void)
 {
   System* s = local::globalMachine->system;
   System::Monitor* lock;
@@ -5220,38 +5564,33 @@ EXPORT(JVM_RawMonitorCreate)(void)
   }
 }
 
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_RawMonitorDestroy)(void* lock)
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(JVM_RawMonitorDestroy)(void* lock)
 {
   static_cast<System::Monitor*>(lock)->dispose();
 }
 
-extern "C" AVIAN_EXPORT jint JNICALL
-EXPORT(JVM_RawMonitorEnter)(void* lock)
+extern "C" AVIAN_EXPORT jint JNICALL EXPORT(JVM_RawMonitorEnter)(void* lock)
 {
-  static_cast<System::Monitor*>(lock)->acquire
-    (static_cast<Thread*>
-     (local::globalMachine->localThread->get())->systemThread);
+  static_cast<System::Monitor*>(lock)
+      ->acquire(static_cast<Thread*>(local::globalMachine->localThread->get())
+                    ->systemThread);
 
   return 0;
 }
 
-extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_RawMonitorExit)(void* lock)
+extern "C" AVIAN_EXPORT void JNICALL EXPORT(JVM_RawMonitorExit)(void* lock)
 {
-  static_cast<System::Monitor*>(lock)->release
-    (static_cast<Thread*>
-     (local::globalMachine->localThread->get())->systemThread);
+  static_cast<System::Monitor*>(lock)
+      ->release(static_cast<Thread*>(local::globalMachine->localThread->get())
+                    ->systemThread);
 }
 
-int JNICALL
-GetVersion(Thread*)
+int JNICALL GetVersion(Thread*)
 {
   return JMM_VERSION_1_0;
 }
 
-uint64_t
-getInputArgumentArray(Thread* t, uintptr_t*)
+uint64_t getInputArgumentArray(Thread* t, uintptr_t*)
 {
   object array
       = makeObjectArray(t, type(t, GcString::Type), t->m->argumentCount);
@@ -5265,21 +5604,18 @@ getInputArgumentArray(Thread* t, uintptr_t*)
   return reinterpret_cast<uintptr_t>(makeLocalReference(t, array));
 }
 
-jobjectArray JNICALL
-GetInputArgumentArray(Thread* t)
+jobjectArray JNICALL GetInputArgumentArray(Thread* t)
 {
   return reinterpret_cast<jobjectArray>(run(t, getInputArgumentArray, 0));
 }
 
-jint JNICALL  
-GetOptionalSupport(Thread*, jmmOptionalSupport* support)
+jint JNICALL GetOptionalSupport(Thread*, jmmOptionalSupport* support)
 {
   memset(support, 0, sizeof(jmmOptionalSupport));
   return 0;
 }
 
-jlong JNICALL
-GetLongAttribute(Thread* t, jobject, jmmLongAttribute attribute)
+jlong JNICALL GetLongAttribute(Thread* t, jobject, jmmLongAttribute attribute)
 {
   const unsigned JMM_JVM_INIT_DONE_TIME_MS = 7;
 
@@ -5292,8 +5628,7 @@ GetLongAttribute(Thread* t, jobject, jmmLongAttribute attribute)
   }
 }
 
-jboolean JNICALL
-GetBoolAttribute(Thread* t, jmmBoolAttribute attribute)
+jboolean JNICALL GetBoolAttribute(Thread* t, jmmBoolAttribute attribute)
 {
   const unsigned JMM_THREAD_CPU_TIME = 24;
   const unsigned JMM_THREAD_ALLOCATED_MEMORY = 25;
@@ -5308,8 +5643,7 @@ GetBoolAttribute(Thread* t, jmmBoolAttribute attribute)
   }
 }
 
-uint64_t
-getMemoryManagers(Thread* t, uintptr_t*)
+uint64_t getMemoryManagers(Thread* t, uintptr_t*)
 {
   return reinterpret_cast<uintptr_t>(makeLocalReference(
       t,
@@ -5320,14 +5654,12 @@ getMemoryManagers(Thread* t, uintptr_t*)
                       0)));
 }
 
-jobjectArray JNICALL
-GetMemoryManagers(Thread* t, jobject)
+jobjectArray JNICALL GetMemoryManagers(Thread* t, jobject)
 {
   return reinterpret_cast<jobjectArray>(run(t, getMemoryManagers, 0));
 }
 
-uint64_t
-getMemoryPools(Thread* t, uintptr_t*)
+uint64_t getMemoryPools(Thread* t, uintptr_t*)
 {
   return reinterpret_cast<uintptr_t>(makeLocalReference(
       t,
@@ -5338,19 +5670,17 @@ getMemoryPools(Thread* t, uintptr_t*)
                       0)));
 }
 
-jobjectArray JNICALL
-GetMemoryPools(Thread* t, jobject)
+jobjectArray JNICALL GetMemoryPools(Thread* t, jobject)
 {
   return reinterpret_cast<jobjectArray>(run(t, getMemoryPools, 0));
 }
 
-extern "C" AVIAN_EXPORT void* JNICALL
-EXPORT(JVM_GetManagement)(jint version)
+extern "C" AVIAN_EXPORT void* JNICALL EXPORT(JVM_GetManagement)(jint version)
 {
   if (version == JMM_VERSION_1_0) {
-    JmmInterface* interface
-      = &(static_cast<MyClasspath*>
-          (local::globalMachine->classpath)->jmmInterface);
+    JmmInterface* interface = &(static_cast<MyClasspath*>(
+                                    local::globalMachine->classpath)
+                                    ->jmmInterface);
 
     memset(interface, 0, sizeof(JmmInterface));
 
@@ -5362,17 +5692,19 @@ EXPORT(JVM_GetManagement)(jint version)
     interface->GetMemoryPools = GetMemoryPools;
     interface->GetInputArgumentArray = GetInputArgumentArray;
 
-    return interface; 
+    return interface;
   } else {
     return 0;
   }
 }
 
 extern "C" AVIAN_EXPORT jobject JNICALL
-EXPORT(JVM_InitAgentProperties)(Thread*, jobject) { abort(); }
+    EXPORT(JVM_InitAgentProperties)(Thread*, jobject)
+{
+  abort();
+}
 
-uint64_t
-getEnclosingMethodInfo(Thread* t, uintptr_t* arguments)
+uint64_t getEnclosingMethodInfo(Thread* t, uintptr_t* arguments)
 {
   jclass c = reinterpret_cast<jclass>(arguments[0]);
   GcClass* class_ = (*c)->vmClass();
@@ -5422,55 +5754,69 @@ getEnclosingMethodInfo(Thread* t, uintptr_t* arguments)
   return 0;
 }
 
-
 extern "C" AVIAN_EXPORT jobjectArray JNICALL
-EXPORT(JVM_GetEnclosingMethodInfo)(Thread* t, jclass c)
+    EXPORT(JVM_GetEnclosingMethodInfo)(Thread* t, jclass c)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c)};
 
-  return reinterpret_cast<jobjectArray>
-    (run(t, getEnclosingMethodInfo, arguments));
+  return reinterpret_cast<jobjectArray>(
+      run(t, getEnclosingMethodInfo, arguments));
 }
 
 extern "C" AVIAN_EXPORT jintArray JNICALL
-EXPORT(JVM_GetThreadStateValues)(JNIEnv*, jint) { abort(); }
+    EXPORT(JVM_GetThreadStateValues)(JNIEnv*, jint)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT jobjectArray JNICALL
-EXPORT(JVM_GetThreadStateNames)(JNIEnv*, jint, jintArray) { abort(); }
+    EXPORT(JVM_GetThreadStateNames)(JNIEnv*, jint, jintArray)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_GetVersionInfo)(JNIEnv*, local::jvm_version_info* info, size_t size)
+    EXPORT(JVM_GetVersionInfo)(JNIEnv*,
+                               local::jvm_version_info* info,
+                               size_t size)
 {
   memset(info, 0, size);
   info->jvm_version = 0x01070000;
 }
 
 extern "C" AVIAN_EXPORT jboolean JNICALL
-EXPORT(JVM_CX8Field)(JNIEnv*, jobject*, jfieldID*, jlong, jlong)
-{ abort(); }
+    EXPORT(JVM_CX8Field)(JNIEnv*, jobject*, jfieldID*, jlong, jlong)
+{
+  abort();
+}
 
 extern "C" AVIAN_EXPORT void JNICALL
-EXPORT(JVM_SetNativeThreadName)(JNIEnv*, jobject, jstring) { abort(); }
+    EXPORT(JVM_SetNativeThreadName)(JNIEnv*, jobject, jstring)
+{
+  abort();
+}
 
-} // namespace local
+}  // namespace local
 
-} // namespace
+}  // namespace
 
-extern "C" AVIAN_EXPORT int
-jio_vsnprintf(char* dst, size_t size, const char* format, va_list a)
+extern "C" AVIAN_EXPORT int jio_vsnprintf(char* dst,
+                                          size_t size,
+                                          const char* format,
+                                          va_list a)
 {
   return vm::vsnprintf(dst, size, format, a);
 }
 
-extern "C" AVIAN_EXPORT int
-jio_vfprintf(FILE* stream, const char* format, va_list a)
+extern "C" AVIAN_EXPORT int jio_vfprintf(FILE* stream,
+                                         const char* format,
+                                         va_list a)
 {
   return vfprintf(stream, format, a);
 }
 
 #ifdef PLATFORM_WINDOWS
-extern "C" AVIAN_EXPORT void* JNICALL
-EXPORT(JVM_GetThreadInterruptEvent)()
+extern "C" AVIAN_EXPORT void* JNICALL EXPORT(JVM_GetThreadInterruptEvent)()
 {
   // hack: We don't want to expose thread interruption implementation
   // details, so we give the class library a fake event to play with.
@@ -5483,26 +5829,29 @@ EXPORT(JVM_GetThreadInterruptEvent)()
   return fake;
 }
 
-namespace { HMODULE jvmHandle = 0; }
+namespace {
+HMODULE jvmHandle = 0;
+}
 
 extern "C" int JDK_InitJvmHandle()
 {
   jvmHandle = GetModuleHandle(0);
   return jvmHandle != 0;
 }
- 
+
 extern "C" void* JDK_FindJvmEntry(const char* name)
 {
   return voidPointer(GetProcAddress(jvmHandle, name));
 }
 
-#  ifdef AVIAN_OPENJDK_SRC
+#ifdef AVIAN_OPENJDK_SRC
 
 extern "C" char* findJavaTZ_md(const char*, const char*);
 
 extern "C" AVIAN_EXPORT int64_t JNICALL
-Avian_java_util_TimeZone_getSystemTimeZoneID
-(Thread* t, object, uintptr_t* arguments)
+    Avian_java_util_TimeZone_getSystemTimeZoneID(Thread* t,
+                                                 object,
+                                                 uintptr_t* arguments)
 {
   // On Windows, findJavaTZ_md loads tzmappings from the filesystem
   // using fopen, so we have no opportunity to make it read straight
@@ -5545,7 +5894,7 @@ Avian_java_util_TimeZone_getSystemTimeZoneID
     return 0;
   }
 
-  THREAD_RESOURCE(t, char*, tmpDir, rmdir(tmpDir)); 
+  THREAD_RESOURCE(t, char*, tmpDir, rmdir(tmpDir));
 
   char libDir[MAX_PATH + 1];
   vm::snprintf(libDir, MAX_PATH, "%s/lib", tmpDir);
@@ -5553,7 +5902,7 @@ Avian_java_util_TimeZone_getSystemTimeZoneID
     return 0;
   }
 
-  THREAD_RESOURCE(t, char*, libDir, rmdir(libDir)); 
+  THREAD_RESOURCE(t, char*, libDir, rmdir(libDir));
 
   char file[MAX_PATH + 1];
   vm::snprintf(file, MAX_PATH, "%s/tzmappings", libDir);
@@ -5561,13 +5910,12 @@ Avian_java_util_TimeZone_getSystemTimeZoneID
   if (out == 0) {
     return 0;
   }
-    
-  THREAD_RESOURCE(t, char*, file, unlink(file)); 
+
+  THREAD_RESOURCE(t, char*, file, unlink(file));
   THREAD_RESOURCE(t, FILE*, out, fclose(out));
 
   if (fwrite(r->start(), 1, r->length(), out) != r->length()
-      or fflush(out) != 0)
-  {
+      or fflush(out) != 0) {
     return 0;
   }
 
@@ -5580,9 +5928,11 @@ Avian_java_util_TimeZone_getSystemTimeZoneID
     return 0;
   }
 }
-#  else // not AVIAN_OPENJDK_SRC
-extern "C" AVIAN_EXPORT int
-jio_snprintf(char* dst, size_t size, const char* format, ...)
+#else   // not AVIAN_OPENJDK_SRC
+extern "C" AVIAN_EXPORT int jio_snprintf(char* dst,
+                                         size_t size,
+                                         const char* format,
+                                         ...)
 {
   va_list a;
   va_start(a, format);
@@ -5594,8 +5944,7 @@ jio_snprintf(char* dst, size_t size, const char* format, ...)
   return r;
 }
 
-extern "C" AVIAN_EXPORT int
-jio_fprintf(FILE* stream, const char* format, ...)
+extern "C" AVIAN_EXPORT int jio_fprintf(FILE* stream, const char* format, ...)
 {
   va_list a;
   va_start(a, format);
@@ -5606,5 +5955,5 @@ jio_fprintf(FILE* stream, const char* format, ...)
 
   return r;
 }
-#  endif // not AVIAN_OPENJDK_SRC
-#endif // PLATFORM_WINDOWS
+#endif  // not AVIAN_OPENJDK_SRC
+#endif  // PLATFORM_WINDOWS
diff --git a/src/codegen/compiler.cpp b/src/codegen/compiler.cpp
index f18a74cfcc..edf2e50218 100644
--- a/src/codegen/compiler.cpp
+++ b/src/codegen/compiler.cpp
@@ -47,32 +47,44 @@ const unsigned StealRegisterReserveCount = 2;
 // compare instruction:
 const unsigned ResolveRegisterReserveCount = (TargetBytesPerWord == 8 ? 2 : 4);
 
-void
-apply(Context* c, lir::UnaryOperation op,
-      unsigned s1Size, Site* s1Low, Site* s1High);
+void apply(Context* c,
+           lir::UnaryOperation op,
+           unsigned s1Size,
+           Site* s1Low,
+           Site* s1High);
 
-void
-apply(Context* c, lir::BinaryOperation op,
-      unsigned s1Size, Site* s1Low, Site* s1High,
-      unsigned s2Size, Site* s2Low, Site* s2High);
-
-void
-apply(Context* c, lir::TernaryOperation op,
-      unsigned s1Size, Site* s1Low, Site* s1High,
-      unsigned s2Size, Site* s2Low, Site* s2High,
-      unsigned s3Size, Site* s3Low, Site* s3High);
+void apply(Context* c,
+           lir::BinaryOperation op,
+           unsigned s1Size,
+           Site* s1Low,
+           Site* s1High,
+           unsigned s2Size,
+           Site* s2Low,
+           Site* s2High);
 
+void apply(Context* c,
+           lir::TernaryOperation op,
+           unsigned s1Size,
+           Site* s1Low,
+           Site* s1High,
+           unsigned s2Size,
+           Site* s2Low,
+           Site* s2High,
+           unsigned s3Size,
+           Site* s3Low,
+           Site* s3High);
 
 class ConstantPoolNode {
  public:
-  ConstantPoolNode(Promise* promise): promise(promise), next(0) { }
+  ConstantPoolNode(Promise* promise) : promise(promise), next(0)
+  {
+  }
 
   Promise* promise;
   ConstantPoolNode* next;
 };
 
-Read*
-live(Context* c UNUSED, Value* v)
+Read* live(Context* c UNUSED, Value* v)
 {
   assertT(c, v->buddy->hasBuddy(c, v));
 
@@ -87,18 +99,16 @@ live(Context* c UNUSED, Value* v)
   return 0;
 }
 
-unsigned
-sitesToString(Context* c, Value* v, char* buffer, unsigned size);
+unsigned sitesToString(Context* c, Value* v, char* buffer, unsigned size);
 
-void
-deadWord(Context* c, Value* v)
+void deadWord(Context* c, Value* v)
 {
   Value* nextWord = v->nextWord;
   assertT(c, nextWord != v);
 
   for (SiteIterator it(c, v, true, false); it.hasMore();) {
     Site* s = it.next();
-    
+
     if (s->registerSize(c) > TargetBytesPerWord) {
       it.remove(c);
       nextWord->addSite(c, s);
@@ -106,8 +116,7 @@ deadWord(Context* c, Value* v)
   }
 }
 
-void
-deadBuddy(Context* c, Value* v, Read* r UNUSED)
+void deadBuddy(Context* c, Value* v, Read* r UNUSED)
 {
   assertT(c, v->buddy != v);
   assertT(c, r);
@@ -125,7 +134,8 @@ deadBuddy(Context* c, Value* v, Read* r UNUSED)
   Value* next = v->buddy;
   v->buddy = v;
   Value* p = next;
-  while (p->buddy != v) p = p->buddy;
+  while (p->buddy != v)
+    p = p->buddy;
   p->buddy = next;
 
   assertT(c, p->buddy);
@@ -133,19 +143,23 @@ deadBuddy(Context* c, Value* v, Read* r UNUSED)
   for (SiteIterator it(c, v, false, false); it.hasMore();) {
     Site* s = it.next();
     it.remove(c);
-    
+
     next->addSite(c, s);
   }
 }
 
-void
-popRead(Context* c, Event* e UNUSED, Value* v)
+void popRead(Context* c, Event* e UNUSED, Value* v)
 {
   assertT(c, e == v->reads->event);
 
   if (DebugReads) {
-    fprintf(stderr, "pop read %p from %p next %p event %p (%s)\n",
-            v->reads, v, v->reads->next(c), e, (e ? e->name() : 0));
+    fprintf(stderr,
+            "pop read %p from %p next %p event %p (%s)\n",
+            v->reads,
+            v,
+            v->reads->next(c),
+            e,
+            (e ? e->name() : 0));
   }
 
   v->reads = v->reads->next(c);
@@ -169,12 +183,12 @@ popRead(Context* c, Event* e UNUSED, Value* v)
   }
 }
 
-void
-addBuddy(Value* original, Value* buddy)
+void addBuddy(Value* original, Value* buddy)
 {
   buddy->buddy = original;
   Value* p = original;
-  while (p->buddy != original) p = p->buddy;
+  while (p->buddy != original)
+    p = p->buddy;
   p->buddy = buddy;
 
   if (DebugBuddies) {
@@ -186,11 +200,9 @@ addBuddy(Value* original, Value* buddy)
   }
 }
 
-void
-move(Context* c, Value* value, Site* src, Site* dst);
+void move(Context* c, Value* value, Site* src, Site* dst);
 
-unsigned
-sitesToString(Context* c, Site* sites, char* buffer, unsigned size)
+unsigned sitesToString(Context* c, Site* sites, char* buffer, unsigned size)
 {
   unsigned total = 0;
   for (Site* s = sites; s; s = s->next) {
@@ -209,8 +221,7 @@ sitesToString(Context* c, Site* sites, char* buffer, unsigned size)
   return total;
 }
 
-unsigned
-sitesToString(Context* c, Value* v, char* buffer, unsigned size)
+unsigned sitesToString(Context* c, Value* v, char* buffer, unsigned size)
 {
   unsigned total = 0;
   Value* p = v;
@@ -234,14 +245,14 @@ sitesToString(Context* c, Value* v, char* buffer, unsigned size)
   return total;
 }
 
-Site*
-pickTargetSite(Context* c, Read* read, bool intersectRead = false,
-               unsigned registerReserveCount = 0,
-               CostCalculator* costCalculator = 0)
+Site* pickTargetSite(Context* c,
+                     Read* read,
+                     bool intersectRead = false,
+                     unsigned registerReserveCount = 0,
+                     CostCalculator* costCalculator = 0)
 {
-  Target target
-    (pickTarget
-     (c, read, intersectRead, registerReserveCount, costCalculator));
+  Target target(
+      pickTarget(c, read, intersectRead, registerReserveCount, costCalculator));
 
   expect(c, target.cost < Target::Impossible);
 
@@ -252,19 +263,21 @@ pickTargetSite(Context* c, Read* read, bool intersectRead = false,
   }
 }
 
-bool
-acceptMatch(Context* c, Site* s, Read*, const SiteMask& mask)
+bool acceptMatch(Context* c, Site* s, Read*, const SiteMask& mask)
 {
   return s->match(c, mask);
 }
 
-Site*
-pickSourceSite(Context* c, Read* read, Site* target = 0,
-               unsigned* cost = 0, SiteMask* extraMask = 0,
-               bool intersectRead = true, bool includeBuddies = true,
-               bool includeNextWord = true,
-               bool (*accept)(Context*, Site*, Read*, const SiteMask&)
-               = acceptMatch)
+Site* pickSourceSite(Context* c,
+                     Read* read,
+                     Site* target = 0,
+                     unsigned* cost = 0,
+                     SiteMask* extraMask = 0,
+                     bool intersectRead = true,
+                     bool includeBuddies = true,
+                     bool includeNextWord = true,
+                     bool (*accept)(Context*, Site*, Read*, const SiteMask&)
+                     = acceptMatch)
 {
   SiteMask mask;
 
@@ -279,8 +292,7 @@ pickSourceSite(Context* c, Read* read, Site* target = 0,
   Site* site = 0;
   unsigned copyCost = 0xFFFFFFFF;
   for (SiteIterator it(c, read->value, includeBuddies, includeNextWord);
-       it.hasMore();)
-  {
+       it.hasMore();) {
     Site* s = it.next();
     if (accept(c, s, read, mask)) {
       unsigned v = s->copyCost(c, target);
@@ -292,38 +304,45 @@ pickSourceSite(Context* c, Read* read, Site* target = 0,
   }
 
   if (DebugMoves and site and target) {
-    char srcb[256]; site->toString(c, srcb, 256);
-    char dstb[256]; target->toString(c, dstb, 256);
-    fprintf(stderr, "pick source %s to %s for %p cost %d\n",
-            srcb, dstb, read->value, copyCost);
+    char srcb[256];
+    site->toString(c, srcb, 256);
+    char dstb[256];
+    target->toString(c, dstb, 256);
+    fprintf(stderr,
+            "pick source %s to %s for %p cost %d\n",
+            srcb,
+            dstb,
+            read->value,
+            copyCost);
   }
 
-  if (cost) *cost = copyCost;
+  if (cost)
+    *cost = copyCost;
   return site;
 }
 
-Site*
-maybeMove(Context* c, Read* read, bool intersectRead, bool includeNextWord,
-          unsigned registerReserveCount = 0)
+Site* maybeMove(Context* c,
+                Read* read,
+                bool intersectRead,
+                bool includeNextWord,
+                unsigned registerReserveCount = 0)
 {
   Value* value = read->value;
   unsigned size = value == value->nextWord ? TargetBytesPerWord : 8;
 
-  class MyCostCalculator: public CostCalculator {
+  class MyCostCalculator : public CostCalculator {
    public:
-    MyCostCalculator(Value* value, unsigned size, bool includeNextWord):
-      value(value),
-      size(size),
-      includeNextWord(includeNextWord)
-    { }
+    MyCostCalculator(Value* value, unsigned size, bool includeNextWord)
+        : value(value), size(size), includeNextWord(includeNextWord)
+    {
+    }
 
     virtual unsigned cost(Context* c, SiteMask dstMask)
     {
       OperandMask src;
       OperandMask tmp;
-      c->arch->planMove
-        (size, src, tmp,
-         OperandMask(dstMask.typeMask, dstMask.registerMask));
+      c->arch->planMove(
+          size, src, tmp, OperandMask(dstMask.typeMask, dstMask.registerMask));
 
       SiteMask srcMask = SiteMask::lowPart(src);
       for (SiteIterator it(c, value, true, includeNextWord); it.hasMore();) {
@@ -341,14 +360,16 @@ maybeMove(Context* c, Read* read, bool intersectRead, bool includeNextWord,
     bool includeNextWord;
   } costCalculator(value, size, includeNextWord);
 
-  Site* dstSite = pickTargetSite
-    (c, read, intersectRead, registerReserveCount, &costCalculator);
+  Site* dstSite = pickTargetSite(
+      c, read, intersectRead, registerReserveCount, &costCalculator);
 
   OperandMask src;
   OperandMask tmp;
-  c->arch->planMove
-    (size, src, tmp,
-     OperandMask(1 << dstSite->type(c), dstSite->registerMask(c)));
+  c->arch->planMove(
+      size,
+      src,
+      tmp,
+      OperandMask(1 << dstSite->type(c), dstSite->registerMask(c)));
 
   SiteMask srcMask = SiteMask::lowPart(src);
   unsigned cost = 0xFFFFFFFF;
@@ -369,20 +390,26 @@ maybeMove(Context* c, Read* read, bool intersectRead, bool includeNextWord,
       cost = v;
     }
   }
- 
+
   if (cost) {
     if (DebugMoves) {
-      char srcb[256]; srcSite->toString(c, srcb, 256);
-      char dstb[256]; dstSite->toString(c, dstb, 256);
-      fprintf(stderr, "maybe move %s to %s for %p to %p\n",
-              srcb, dstb, value, value);
+      char srcb[256];
+      srcSite->toString(c, srcb, 256);
+      char dstb[256];
+      dstSite->toString(c, dstb, 256);
+      fprintf(stderr,
+              "maybe move %s to %s for %p to %p\n",
+              srcb,
+              dstb,
+              value,
+              value);
     }
 
     srcSite->freeze(c, value);
 
     value->addSite(c, dstSite);
-    
-    srcSite->thaw(c, value);    
+
+    srcSite->thaw(c, value);
 
     if (not srcSite->match(c, srcMask)) {
       srcSite->freeze(c, value);
@@ -398,7 +425,7 @@ maybeMove(Context* c, Read* read, bool intersectRead, bool includeNextWord,
       value->addSite(c, tmpSite);
 
       move(c, value, srcSite, tmpSite);
-      
+
       dstSite->thaw(c, value);
       srcSite->thaw(c, value);
 
@@ -411,58 +438,70 @@ maybeMove(Context* c, Read* read, bool intersectRead, bool includeNextWord,
   return dstSite;
 }
 
-Site*
-maybeMove(Context* c, Value* v, const SiteMask& mask, bool intersectMask,
-          bool includeNextWord, unsigned registerReserveCount = 0)
+Site* maybeMove(Context* c,
+                Value* v,
+                const SiteMask& mask,
+                bool intersectMask,
+                bool includeNextWord,
+                unsigned registerReserveCount = 0)
 {
   SingleRead read(mask, 0);
   read.value = v;
   read.successor_ = v;
 
-  return maybeMove
-    (c, &read, intersectMask, includeNextWord, registerReserveCount);
+  return maybeMove(
+      c, &read, intersectMask, includeNextWord, registerReserveCount);
 }
 
-Site*
-pickSiteOrMove(Context* c, Read* read, bool intersectRead,
-               bool includeNextWord, unsigned registerReserveCount = 0)
+Site* pickSiteOrMove(Context* c,
+                     Read* read,
+                     bool intersectRead,
+                     bool includeNextWord,
+                     unsigned registerReserveCount = 0)
 {
-  Site* s = pickSourceSite
-    (c, read, 0, 0, 0, intersectRead, true, includeNextWord);
-  
+  Site* s
+      = pickSourceSite(c, read, 0, 0, 0, intersectRead, true, includeNextWord);
+
   if (s) {
     return s;
   } else {
-    return maybeMove
-      (c, read, intersectRead, includeNextWord, registerReserveCount);
+    return maybeMove(
+        c, read, intersectRead, includeNextWord, registerReserveCount);
   }
 }
 
-Site*
-pickSiteOrMove(Context* c, Value* v, const SiteMask& mask, bool intersectMask,
-               bool includeNextWord, unsigned registerReserveCount = 0)
+Site* pickSiteOrMove(Context* c,
+                     Value* v,
+                     const SiteMask& mask,
+                     bool intersectMask,
+                     bool includeNextWord,
+                     unsigned registerReserveCount = 0)
 {
   SingleRead read(mask, 0);
   read.value = v;
   read.successor_ = v;
 
-  return pickSiteOrMove
-    (c, &read, intersectMask, includeNextWord, registerReserveCount);
+  return pickSiteOrMove(
+      c, &read, intersectMask, includeNextWord, registerReserveCount);
 }
 
-void
-steal(Context* c, Resource* r, Value* thief)
+void steal(Context* c, Resource* r, Value* thief)
 {
   if (DebugResources) {
-    char resourceBuffer[256]; r->toString(c, resourceBuffer, 256);
-    char siteBuffer[1024]; sitesToString(c, r->value, siteBuffer, 1024);
-    fprintf(stderr, "%p steal %s from %p (%s)\n",
-            thief, resourceBuffer, r->value, siteBuffer);
+    char resourceBuffer[256];
+    r->toString(c, resourceBuffer, 256);
+    char siteBuffer[1024];
+    sitesToString(c, r->value, siteBuffer, 1024);
+    fprintf(stderr,
+            "%p steal %s from %p (%s)\n",
+            thief,
+            resourceBuffer,
+            r->value,
+            siteBuffer);
   }
 
-  if ((not (thief and thief->isBuddyOf(r->value))
-       and r->value->uniqueSite(c, r->site)))
-  {
+  if ((not(thief and thief->isBuddyOf(r->value))
+       and r->value->uniqueSite(c, r->site))) {
     r->site->freeze(c, r->value);
 
     maybeMove(c, live(c, r->value), false, true, StealRegisterReserveCount);
@@ -473,35 +512,35 @@ steal(Context* c, Resource* r, Value* thief)
   r->value->removeSite(c, r->site);
 }
 
-SiteMask
-generalRegisterMask(Context* c)
+SiteMask generalRegisterMask(Context* c)
 {
-  return SiteMask
-    (1 << lir::RegisterOperand, c->regFile->generalRegisters.mask, NoFrameIndex);
+  return SiteMask(1 << lir::RegisterOperand,
+                  c->regFile->generalRegisters.mask,
+                  NoFrameIndex);
 }
 
-SiteMask
-generalRegisterOrConstantMask(Context* c)
+SiteMask generalRegisterOrConstantMask(Context* c)
 {
-  return SiteMask
-    ((1 << lir::RegisterOperand) | (1 << lir::ConstantOperand),
-     c->regFile->generalRegisters.mask, NoFrameIndex);
+  return SiteMask((1 << lir::RegisterOperand) | (1 << lir::ConstantOperand),
+                  c->regFile->generalRegisters.mask,
+                  NoFrameIndex);
 }
 
-MultiRead*
-multiRead(Context* c)
+MultiRead* multiRead(Context* c)
 {
-  return new(c->zone) MultiRead;
+  return new (c->zone) MultiRead;
 }
 
-StubRead*
-stubRead(Context* c)
+StubRead* stubRead(Context* c)
 {
-  return new(c->zone) StubRead;
+  return new (c->zone) StubRead;
 }
 
-Site*
-pickSite(Context* c, Value* v, Site* s, unsigned index, bool includeNextWord)
+Site* pickSite(Context* c,
+               Value* v,
+               Site* s,
+               unsigned index,
+               bool includeNextWord)
 {
   for (SiteIterator it(c, v, true, includeNextWord); it.hasMore();) {
     Site* candidate = it.next();
@@ -513,8 +552,7 @@ pickSite(Context* c, Value* v, Site* s, unsigned index, bool includeNextWord)
   return 0;
 }
 
-Site*
-pickSiteOrMove(Context* c, Value* v, Site* s, unsigned index)
+Site* pickSiteOrMove(Context* c, Value* v, Site* s, unsigned index)
 {
   Site* n = pickSite(c, v, s, index, false);
   if (n) {
@@ -524,8 +562,7 @@ pickSiteOrMove(Context* c, Value* v, Site* s, unsigned index)
   return maybeMove(c, v, s->nextWordMask(c, index), true, false);
 }
 
-Site*
-pickSiteOrMove(Context* c, Value* v, Site* s, Site** low, Site** high)
+Site* pickSiteOrMove(Context* c, Value* v, Site* s, Site** low, Site** high)
 {
   if (v->wordIndex == 0) {
     *low = s;
@@ -538,8 +575,7 @@ pickSiteOrMove(Context* c, Value* v, Site* s, Site** low, Site** high)
   }
 }
 
-Site*
-pickSiteOrGrow(Context* c, Value* v, Site* s, unsigned index)
+Site* pickSiteOrGrow(Context* c, Value* v, Site* s, unsigned index)
 {
   Site* n = pickSite(c, v, s, index, false);
   if (n) {
@@ -551,8 +587,7 @@ pickSiteOrGrow(Context* c, Value* v, Site* s, unsigned index)
   return n;
 }
 
-Site*
-pickSiteOrGrow(Context* c, Value* v, Site* s, Site** low, Site** high)
+Site* pickSiteOrGrow(Context* c, Value* v, Site* s, Site** low, Site** high)
 {
   if (v->wordIndex == 0) {
     *low = s;
@@ -565,8 +600,7 @@ pickSiteOrGrow(Context* c, Value* v, Site* s, Site** low, Site** high)
   }
 }
 
-bool
-isHome(Value* v, int frameIndex)
+bool isHome(Value* v, int frameIndex)
 {
   Value* p = v;
   do {
@@ -579,8 +613,7 @@ isHome(Value* v, int frameIndex)
   return false;
 }
 
-bool
-acceptForResolve(Context* c, Site* s, Read* read, const SiteMask& mask)
+bool acceptForResolve(Context* c, Site* s, Read* read, const SiteMask& mask)
 {
   if (acceptMatch(c, s, read, mask) and (not s->frozen(c))) {
     if (s->type(c) == lir::RegisterOperand) {
@@ -589,29 +622,29 @@ acceptForResolve(Context* c, Site* s, Read* read, const SiteMask& mask)
       assertT(c,
               s->match(c, SiteMask(1 << lir::MemoryOperand, 0, AnyFrameIndex)));
 
-      return isHome(read->value, offsetToFrameIndex
-                    (c, static_cast<MemorySite*>(s)->offset));
+      return isHome(read->value,
+                    offsetToFrameIndex(c, static_cast<MemorySite*>(s)->offset));
     }
   } else {
     return false;
   }
 }
 
-void
-move(Context* c, Value* value, Site* src, Site* dst)
+void move(Context* c, Value* value, Site* src, Site* dst)
 {
   if (DebugMoves) {
-    char srcb[256]; src->toString(c, srcb, 256);
-    char dstb[256]; dst->toString(c, dstb, 256);
-    fprintf(stderr, "move %s to %s for %p to %p\n",
-            srcb, dstb, value, value);
+    char srcb[256];
+    src->toString(c, srcb, 256);
+    char dstb[256];
+    dst->toString(c, dstb, 256);
+    fprintf(stderr, "move %s to %s for %p to %p\n", srcb, dstb, value, value);
   }
 
   assertT(c, value->findSite(dst));
 
   src->freeze(c, value);
   dst->freeze(c, value);
-  
+
   unsigned srcSize;
   unsigned dstSize;
   if (value->nextWord == value) {
@@ -644,14 +677,12 @@ move(Context* c, Value* value, Site* src, Site* dst)
   src->thaw(c, value);
 }
 
-void
-asAssemblerOperand(Context* c, Site* low, Site* high,
-                   lir::Operand* result)
+void asAssemblerOperand(Context* c, Site* low, Site* high, lir::Operand* result)
 {
   low->asAssemblerOperand(c, high, result);
 }
 
-class OperandUnion: public lir::Operand {
+class OperandUnion : public lir::Operand {
  public:
   // must be large enough and aligned properly to hold any operand
   // type (we'd use an actual union type here, except that classes
@@ -659,79 +690,99 @@ class OperandUnion: public lir::Operand {
   uintptr_t padding[4];
 };
 
-void
-apply(Context* c, lir::UnaryOperation op,
-      unsigned s1Size, Site* s1Low, Site* s1High)
+void apply(Context* c,
+           lir::UnaryOperation op,
+           unsigned s1Size,
+           Site* s1Low,
+           Site* s1High)
 {
   assertT(c, s1Low->type(c) == s1High->type(c));
 
   lir::OperandType s1Type = s1Low->type(c);
-  OperandUnion s1Union; asAssemblerOperand(c, s1Low, s1High, &s1Union);
+  OperandUnion s1Union;
+  asAssemblerOperand(c, s1Low, s1High, &s1Union);
 
-  c->assembler->apply(op,
-    OperandInfo(s1Size, s1Type, &s1Union));
+  c->assembler->apply(op, OperandInfo(s1Size, s1Type, &s1Union));
 }
 
-void
-apply(Context* c, lir::BinaryOperation op,
-      unsigned s1Size, Site* s1Low, Site* s1High,
-      unsigned s2Size, Site* s2Low, Site* s2High)
+void apply(Context* c,
+           lir::BinaryOperation op,
+           unsigned s1Size,
+           Site* s1Low,
+           Site* s1High,
+           unsigned s2Size,
+           Site* s2Low,
+           Site* s2High)
 {
   assertT(c, s1Low->type(c) == s1High->type(c));
   assertT(c, s2Low->type(c) == s2High->type(c));
 
   lir::OperandType s1Type = s1Low->type(c);
-  OperandUnion s1Union; asAssemblerOperand(c, s1Low, s1High, &s1Union);
+  OperandUnion s1Union;
+  asAssemblerOperand(c, s1Low, s1High, &s1Union);
 
   lir::OperandType s2Type = s2Low->type(c);
-  OperandUnion s2Union; asAssemblerOperand(c, s2Low, s2High, &s2Union);
+  OperandUnion s2Union;
+  asAssemblerOperand(c, s2Low, s2High, &s2Union);
 
   c->assembler->apply(op,
-    OperandInfo(s1Size, s1Type, &s1Union),
-    OperandInfo(s2Size, s2Type, &s2Union));
+                      OperandInfo(s1Size, s1Type, &s1Union),
+                      OperandInfo(s2Size, s2Type, &s2Union));
 }
 
-void
-apply(Context* c, lir::TernaryOperation op,
-      unsigned s1Size, Site* s1Low, Site* s1High,
-      unsigned s2Size, Site* s2Low, Site* s2High,
-      unsigned s3Size, Site* s3Low, Site* s3High)
+void apply(Context* c,
+           lir::TernaryOperation op,
+           unsigned s1Size,
+           Site* s1Low,
+           Site* s1High,
+           unsigned s2Size,
+           Site* s2Low,
+           Site* s2High,
+           unsigned s3Size,
+           Site* s3Low,
+           Site* s3High)
 {
   assertT(c, s1Low->type(c) == s1High->type(c));
   assertT(c, s2Low->type(c) == s2High->type(c));
   assertT(c, s3Low->type(c) == s3High->type(c));
 
   lir::OperandType s1Type = s1Low->type(c);
-  OperandUnion s1Union; asAssemblerOperand(c, s1Low, s1High, &s1Union);
+  OperandUnion s1Union;
+  asAssemblerOperand(c, s1Low, s1High, &s1Union);
 
   lir::OperandType s2Type = s2Low->type(c);
-  OperandUnion s2Union; asAssemblerOperand(c, s2Low, s2High, &s2Union);
+  OperandUnion s2Union;
+  asAssemblerOperand(c, s2Low, s2High, &s2Union);
 
   lir::OperandType s3Type = s3Low->type(c);
-  OperandUnion s3Union; asAssemblerOperand(c, s3Low, s3High, &s3Union);
+  OperandUnion s3Union;
+  asAssemblerOperand(c, s3Low, s3High, &s3Union);
 
   c->assembler->apply(op,
-    OperandInfo(s1Size, s1Type, &s1Union),
-    OperandInfo(s2Size, s2Type, &s2Union),
-    OperandInfo(s3Size, s3Type, &s3Union));
+                      OperandInfo(s1Size, s1Type, &s1Union),
+                      OperandInfo(s2Size, s2Type, &s2Union),
+                      OperandInfo(s3Size, s3Type, &s3Union));
 }
 
-void
-append(Context* c, Event* e);
+void append(Context* c, Event* e);
 
-void
-saveLocals(Context* c, Event* e)
+void saveLocals(Context* c, Event* e)
 {
   for (unsigned li = 0; li < c->localFootprint; ++li) {
     Local* local = e->localsBefore + li;
     if (local->value) {
       if (DebugReads) {
-        fprintf(stderr, "local save read %p at %d of %d\n",
-                local->value, compiler::frameIndex(c, li), totalFrameSize(c));
+        fprintf(stderr,
+                "local save read %p at %d of %d\n",
+                local->value,
+                compiler::frameIndex(c, li),
+                totalFrameSize(c));
       }
 
-      e->addRead(c, local->value, SiteMask
-              (1 << lir::MemoryOperand, 0, compiler::frameIndex(c, li)));
+      e->addRead(
+          c,
+          local->value,
+          SiteMask(1 << lir::MemoryOperand, 0, compiler::frameIndex(c, li)));
     }
   }
 }
@@ -759,7 +810,8 @@ void maybeMove(Context* c,
 
   unsigned cost = srcValue->source->copyCost(c, target);
 
-  if (srcSelectSize < dstSize) cost = 1;
+  if (srcSelectSize < dstSize)
+    cost = 1;
 
   if (cost) {
     // todo: let c->arch->planMove decide this:
@@ -774,23 +826,28 @@ void maybeMove(Context* c,
 
     srcValue->source->thaw(c, srcValue);
 
-    bool addOffset = srcSize != srcSelectSize
-      and c->arch->bigEndian()
-      and srcValue->source->type(c) == lir::MemoryOperand;
+    bool addOffset = srcSize != srcSelectSize and c->arch->bigEndian()
+                     and srcValue->source->type(c) == lir::MemoryOperand;
 
     if (addOffset) {
       static_cast<MemorySite*>(srcValue->source)->offset
-        += (srcSize - srcSelectSize);
+          += (srcSize - srcSelectSize);
     }
 
     target->freeze(c, dstValue);
 
     if (target->match(c, dstMask) and not useTemporary) {
       if (DebugMoves) {
-        char srcb[256]; srcValue->source->toString(c, srcb, 256);
-        char dstb[256]; target->toString(c, dstb, 256);
-        fprintf(stderr, "move %s to %s for %p to %p\n",
-                srcb, dstb, srcValue, dstValue);
+        char srcb[256];
+        srcValue->source->toString(c, srcb, 256);
+        char dstb[256];
+        target->toString(c, dstb, 256);
+        fprintf(stderr,
+                "move %s to %s for %p to %p\n",
+                srcb,
+                dstb,
+                srcValue,
+                dstValue);
       }
 
       srcValue->source->freeze(c, srcValue);
@@ -808,7 +865,7 @@ void maybeMove(Context* c,
     } else {
       // pick a temporary register which is valid as both a
       // destination and a source for the moves we need to perform:
-      
+
       dstValue->removeSite(c, target);
 
       bool thunk;
@@ -823,8 +880,8 @@ void maybeMove(Context* c,
       assertT(c, thunk == 0);
       assertT(c, dstMask.typeMask & src.typeMask & (1 << lir::RegisterOperand));
 
-      Site* tmpTarget = freeRegisterSite
-        (c, dstMask.registerMask & src.registerMask);
+      Site* tmpTarget
+          = freeRegisterSite(c, dstMask.registerMask & src.registerMask);
 
       srcValue->source->freeze(c, srcValue);
 
@@ -833,10 +890,16 @@ void maybeMove(Context* c,
       tmpTarget->freeze(c, dstValue);
 
       if (DebugMoves) {
-        char srcb[256]; srcValue->source->toString(c, srcb, 256);
-        char dstb[256]; tmpTarget->toString(c, dstb, 256);
-        fprintf(stderr, "move %s to %s for %p to %p\n",
-                srcb, dstb, srcValue, dstValue);
+        char srcb[256];
+        srcValue->source->toString(c, srcb, 256);
+        char dstb[256];
+        tmpTarget->toString(c, dstb, 256);
+        fprintf(stderr,
+                "move %s to %s for %p to %p\n",
+                srcb,
+                dstb,
+                srcValue,
+                dstValue);
       }
 
       apply(c,
@@ -854,17 +917,30 @@ void maybeMove(Context* c,
 
       if (useTemporary or isStore) {
         if (DebugMoves) {
-          char srcb[256]; tmpTarget->toString(c, srcb, 256);
-          char dstb[256]; target->toString(c, dstb, 256);
-          fprintf(stderr, "move %s to %s for %p to %p\n",
-                  srcb, dstb, srcValue, dstValue);
+          char srcb[256];
+          tmpTarget->toString(c, srcb, 256);
+          char dstb[256];
+          target->toString(c, dstb, 256);
+          fprintf(stderr,
+                  "move %s to %s for %p to %p\n",
+                  srcb,
+                  dstb,
+                  srcValue,
+                  dstValue);
         }
 
         dstValue->addSite(c, target);
 
         tmpTarget->freeze(c, dstValue);
 
-        apply(c, lir::Move, dstSize, tmpTarget, tmpTarget, dstSize, target, target);
+        apply(c,
+              lir::Move,
+              dstSize,
+              tmpTarget,
+              tmpTarget,
+              dstSize,
+              target,
+              target);
 
         tmpTarget->thaw(c, dstValue);
 
@@ -878,14 +954,16 @@ void maybeMove(Context* c,
 
     if (addOffset) {
       static_cast<MemorySite*>(srcValue->source)->offset
-        -= (srcSize - srcSelectSize);
+          -= (srcSize - srcSelectSize);
     }
   } else {
     target = srcValue->source;
 
     if (DebugMoves) {
-      char dstb[256]; target->toString(c, dstb, 256);
-      fprintf(stderr, "null move in %s for %p to %p\n", dstb, srcValue, dstValue);
+      char dstb[256];
+      target->toString(c, dstb, 256);
+      fprintf(
+          stderr, "null move in %s for %p to %p\n", dstb, srcValue, dstValue);
     }
   }
 
@@ -894,9 +972,11 @@ void maybeMove(Context* c,
   }
 }
 
-Site*
-pickMatchOrMove(Context* c, Read* r, Site* nextWord, unsigned index,
-                bool intersectRead)
+Site* pickMatchOrMove(Context* c,
+                      Read* r,
+                      Site* nextWord,
+                      unsigned index,
+                      bool intersectRead)
 {
   Site* s = pickSite(c, r->value, nextWord, index, true);
   SiteMask mask;
@@ -907,14 +987,18 @@ pickMatchOrMove(Context* c, Read* r, Site* nextWord, unsigned index,
     return s;
   }
 
-  return pickSiteOrMove
-    (c, r->value, mask.intersectionWith(nextWord->nextWordMask(c, index)),
-     true, true);
+  return pickSiteOrMove(c,
+                        r->value,
+                        mask.intersectionWith(nextWord->nextWordMask(c, index)),
+                        true,
+                        true);
 }
 
-Site*
-pickSiteOrMove(Context* c, Value* src, Value* dst, Site* nextWord,
-               unsigned index)
+Site* pickSiteOrMove(Context* c,
+                     Value* src,
+                     Value* dst,
+                     Site* nextWord,
+                     unsigned index)
 {
   if (live(c, dst)) {
     Read* read = live(c, src);
@@ -942,20 +1026,18 @@ pickSiteOrMove(Context* c, Value* src, Value* dst, Site* nextWord,
   }
 }
 
-ConstantSite*
-findConstantSite(Context* c, Value* v);
+ConstantSite* findConstantSite(Context* c, Value* v);
 
-Site*
-getTarget(Context* c, Value* value, Value* result, const SiteMask& resultMask);
+Site* getTarget(Context* c,
+                Value* value,
+                Value* result,
+                const SiteMask& resultMask);
 
-void
-freezeSource(Context* c, unsigned size, Value* v);
+void freezeSource(Context* c, unsigned size, Value* v);
 
-void
-thawSource(Context* c, unsigned size, Value* v);
+void thawSource(Context* c, unsigned size, Value* v);
 
-void
-removeBuddy(Context* c, Value* v)
+void removeBuddy(Context* c, Value* v)
 {
   if (v->buddy != v) {
     if (DebugBuddies) {
@@ -971,7 +1053,8 @@ removeBuddy(Context* c, Value* v)
     Value* next = v->buddy;
     v->buddy = v;
     Value* p = next;
-    while (p->buddy != v) p = p->buddy;
+    while (p->buddy != v)
+      p = p->buddy;
     p->buddy = next;
 
     assertT(c, p->buddy);
@@ -986,8 +1069,7 @@ removeBuddy(Context* c, Value* v)
   }
 }
 
-Site*
-copy(Context* c, Site* s)
+Site* copy(Context* c, Site* s)
 {
   Site* start = 0;
   Site* end = 0;
@@ -1005,9 +1087,13 @@ copy(Context* c, Site* s)
 
 class Snapshot {
  public:
-  Snapshot(Context* c, Value* value, Snapshot* next):
-    value(value), buddy(value->buddy), sites(copy(c, value->sites)), next(next)
-  { }
+  Snapshot(Context* c, Value* value, Snapshot* next)
+      : value(value),
+        buddy(value->buddy),
+        sites(copy(c, value->sites)),
+        next(next)
+  {
+  }
 
   Value* value;
   Value* buddy;
@@ -1015,20 +1101,19 @@ class Snapshot {
   Snapshot* next;
 };
 
-Snapshot*
-snapshot(Context* c, Value* value, Snapshot* next)
+Snapshot* snapshot(Context* c, Value* value, Snapshot* next)
 {
   if (DebugControl) {
-    char buffer[256]; sitesToString(c, value->sites, buffer, 256);
-    fprintf(stderr, "snapshot %p buddy %p sites %s\n",
-            value, value->buddy, buffer);
+    char buffer[256];
+    sitesToString(c, value->sites, buffer, 256);
+    fprintf(
+        stderr, "snapshot %p buddy %p sites %s\n", value, value->buddy, buffer);
   }
 
-  return new(c->zone) Snapshot(c, value, next);
+  return new (c->zone) Snapshot(c, value, next);
 }
 
-Snapshot*
-makeSnapshots(Context* c, Value* value, Snapshot* next)
+Snapshot* makeSnapshots(Context* c, Value* value, Snapshot* next)
 {
   next = snapshot(c, value, next);
   for (Value* p = value->buddy; p != value; p = p->buddy) {
@@ -1037,16 +1122,14 @@ makeSnapshots(Context* c, Value* value, Snapshot* next)
   return next;
 }
 
-Value*
-maybeBuddy(Context* c, Value* v);
+Value* maybeBuddy(Context* c, Value* v);
 
-Value*
-pushWord(Context* c, Value* v)
+Value* pushWord(Context* c, Value* v)
 {
   if (v) {
     v = maybeBuddy(c, v);
   }
-    
+
   Stack* s = stack(c, v, c->stack);
 
   if (DebugFrame) {
@@ -1061,15 +1144,14 @@ pushWord(Context* c, Value* v)
   return v;
 }
 
-void
-push(Context* c, unsigned footprint, Value* v)
+void push(Context* c, unsigned footprint, Value* v)
 {
   assertT(c, footprint);
 
   bool bigEndian = c->arch->bigEndian();
-  
+
   Value* low = v;
-  
+
   if (bigEndian) {
     v = pushWord(c, v);
   }
@@ -1087,7 +1169,7 @@ push(Context* c, unsigned footprint, Value* v)
   } else {
     high = 0;
   }
-  
+
   if (not bigEndian) {
     v = pushWord(c, v);
   }
@@ -1099,8 +1181,7 @@ push(Context* c, unsigned footprint, Value* v)
   }
 }
 
-void
-popWord(Context* c)
+void popWord(Context* c)
 {
   Stack* s = c->stack;
   assertT(c, s->value == 0 or s->value->home >= 0);
@@ -1108,12 +1189,11 @@ popWord(Context* c)
   if (DebugFrame) {
     fprintf(stderr, "pop %p\n", s->value);
   }
-    
-  c->stack = s->next;  
+
+  c->stack = s->next;
 }
 
-Value*
-pop(Context* c, unsigned footprint)
+Value* pop(Context* c, unsigned footprint)
 {
   assertT(c, footprint);
 
@@ -1144,7 +1224,7 @@ pop(Context* c, unsigned footprint)
         (TargetBytesPerWord == 8 and low->value->nextWord == low->value
          and high->value == 0)
         or (TargetBytesPerWord == 4 and low->value->nextWord == high->value));
-#endif // not NDEBUG
+#endif  // not NDEBUG
 
     popWord(c);
   }
@@ -1158,8 +1238,11 @@ pop(Context* c, unsigned footprint)
   return s->value;
 }
 
-Value*
-storeLocal(Context* c, unsigned footprint, Value* v, unsigned index, bool copy)
+Value* storeLocal(Context* c,
+                  unsigned footprint,
+                  Value* v,
+                  unsigned index,
+                  bool copy)
 {
   assertT(c, index + footprint <= c->localFootprint);
 
@@ -1181,7 +1264,7 @@ storeLocal(Context* c, unsigned footprint, Value* v, unsigned index, bool copy)
       lowIndex = index;
     } else {
       lowIndex = index + 1;
-      highIndex = index;      
+      highIndex = index;
     }
 
     if (TargetBytesPerWord == 4) {
@@ -1244,7 +1327,7 @@ Value* loadLocal(Context* c, ir::Type type, unsigned index)
     assertT(c, footprint == 2);
 
     if (not c->arch->bigEndian()) {
-      ++ index;
+      ++index;
     }
   }
 
@@ -1264,14 +1347,12 @@ Value* threadRegister(Context* c)
   return value(c, ir::Type::addr(), s, s);
 }
 
-unsigned
-frameFootprint(Context* c, Stack* s)
+unsigned frameFootprint(Context* c, Stack* s)
 {
   return c->localFootprint + (s ? (s->index + 1) : 0);
 }
 
-void
-visit(Context* c, Link* link)
+void visit(Context* c, Link* link)
 {
   //   fprintf(stderr, "visit link from %d to %d fork %p junction %p\n",
   //           link->predecessor->logicalInstruction->index,
@@ -1285,7 +1366,8 @@ visit(Context* c, Link* link)
       ForkElement* p = forkState->elements + i;
       Value* v = p->value;
       v->reads = p->read->nextTarget();
-      //       fprintf(stderr, "next read %p for %p from %p\n", v->reads, v, p->read);
+      //       fprintf(stderr, "next read %p for %p from %p\n", v->reads, v,
+      //       p->read);
       if (not live(c, v)) {
         v->clearSites(c);
       }
@@ -1296,7 +1378,7 @@ visit(Context* c, Link* link)
   if (junctionState) {
     for (unsigned i = 0; i < junctionState->frameFootprint; ++i) {
       StubReadPair* p = junctionState->reads + i;
-      
+
       if (p->value and p->value->reads) {
         assertT(c, p->value->reads == p->read);
         popRead(c, 0, p->value);
@@ -1305,19 +1387,21 @@ visit(Context* c, Link* link)
   }
 }
 
-class BuddyEvent: public Event {
+class BuddyEvent : public Event {
  public:
-  BuddyEvent(Context* c, Value* original, Value* buddy):
-    Event(c), original(original), buddy(buddy)
+  BuddyEvent(Context* c, Value* original, Value* buddy)
+      : Event(c), original(original), buddy(buddy)
   {
     this->addRead(c, original, SiteMask(~0, ~0, AnyFrameIndex), buddy);
   }
 
-  virtual const char* name() {
+  virtual const char* name()
+  {
     return "BuddyEvent";
   }
 
-  virtual void compile(Context* c) {
+  virtual void compile(Context* c)
+  {
     if (DebugBuddies) {
       fprintf(stderr, "original %p buddy %p\n", original, buddy);
     }
@@ -1336,14 +1420,12 @@ class BuddyEvent: public Event {
   Value* buddy;
 };
 
-void
-appendBuddy(Context* c, Value* original, Value* buddy)
+void appendBuddy(Context* c, Value* original, Value* buddy)
 {
-  append(c, new(c->zone) BuddyEvent(c, original, buddy));
+  append(c, new (c->zone) BuddyEvent(c, original, buddy));
 }
 
-void
-append(Context* c, Event* e)
+void append(Context* c, Event* e)
 {
   LogicalInstruction* i = c->logicalCode[c->logicalIp];
   if (c->stack != i->stack or c->locals != i->locals) {
@@ -1351,9 +1433,11 @@ append(Context* c, Event* e)
   }
 
   if (DebugAppend) {
-    fprintf(stderr, " -- append %s at %d with %d stack before\n",
-            e->name(), e->logicalInstruction->index, c->stack ?
-            c->stack->index + 1 : 0);
+    fprintf(stderr,
+            " -- append %s at %d with %d stack before\n",
+            e->name(),
+            e->logicalInstruction->index,
+            c->stack ? c->stack->index + 1 : 0);
   }
 
   if (c->lastEvent) {
@@ -1366,12 +1450,14 @@ append(Context* c, Event* e)
   Event* p = c->predecessor;
   if (p) {
     if (DebugAppend) {
-      fprintf(stderr, "%d precedes %d\n", p->logicalInstruction->index,
+      fprintf(stderr,
+              "%d precedes %d\n",
+              p->logicalInstruction->index,
               e->logicalInstruction->index);
     }
 
-    Link* link = compiler::link
-      (c, p, e->predecessors, e, p->successors, c->forkState);
+    Link* link
+        = compiler::link(c, p, e->predecessors, e, p->successors, c->forkState);
     e->predecessors = link;
     p->successors = link;
   }
@@ -1385,13 +1471,13 @@ append(Context* c, Event* e)
   e->logicalInstruction->lastEvent = e;
 }
 
-Site*
-readSource(Context* c, Read* r)
+Site* readSource(Context* c, Read* r)
 {
   Value* v = r->value;
 
   if (DebugReads) {
-    char buffer[1024]; sitesToString(c, v, buffer, 1024);
+    char buffer[1024];
+    sitesToString(c, v, buffer, 1024);
     fprintf(stderr, "read source for %p from %s\n", v, buffer);
   }
 
@@ -1410,8 +1496,7 @@ readSource(Context* c, Read* r)
   }
 }
 
-void
-propagateJunctionSites(Context* c, Event* e, Site** sites)
+void propagateJunctionSites(Context* c, Event* e, Site** sites)
 {
   for (Link* pl = e->predecessors; pl; pl = pl->nextPredecessor) {
     Event* p = pl->predecessor;
@@ -1425,15 +1510,13 @@ propagateJunctionSites(Context* c, Event* e, Site** sites)
   }
 }
 
-void
-propagateJunctionSites(Context* c, Event* e)
+void propagateJunctionSites(Context* c, Event* e)
 {
   for (Link* sl = e->successors; sl; sl = sl->nextSuccessor) {
     Event* s = sl->successor;
     if (s->predecessors->nextPredecessor) {
       unsigned size = sizeof(Site*) * frameFootprint(c, e->stackAfter);
-      Site** junctionSites = static_cast<Site**>
-        (c->zone->allocate(size));
+      Site** junctionSites = static_cast<Site**>(c->zone->allocate(size));
       memset(junctionSites, 0, size);
 
       propagateJunctionSites(c, s, junctionSites);
@@ -1448,8 +1531,7 @@ class SiteRecord {
   Value* value;
 };
 
-void
-init(SiteRecord* r, Site* s, Value* v)
+void init(SiteRecord* r, Site* s, Value* v)
 {
   r->site = s;
   r->value = v;
@@ -1457,41 +1539,40 @@ init(SiteRecord* r, Site* s, Value* v)
 
 class SiteRecordList {
  public:
-  SiteRecordList(SiteRecord* records, unsigned capacity):
-    records(records), index(0), capacity(capacity)
-  { }
+  SiteRecordList(SiteRecord* records, unsigned capacity)
+      : records(records), index(0), capacity(capacity)
+  {
+  }
 
   SiteRecord* records;
   unsigned index;
   unsigned capacity;
 };
 
-void
-freeze(Context* c, SiteRecordList* frozen, Site* s, Value* v)
+void freeze(Context* c, SiteRecordList* frozen, Site* s, Value* v)
 {
   assertT(c, frozen->index < frozen->capacity);
 
   s->freeze(c, v);
-  init(new (frozen->records + (frozen->index ++)) SiteRecord, s, v);
+  init(new (frozen->records + (frozen->index++)) SiteRecord, s, v);
 }
 
-void
-thaw(Context* c, SiteRecordList* frozen)
+void thaw(Context* c, SiteRecordList* frozen)
 {
   while (frozen->index) {
-    SiteRecord* sr = frozen->records + (-- frozen->index);
+    SiteRecord* sr = frozen->records + (--frozen->index);
     sr->site->thaw(c, sr->value);
   }
 }
 
-bool
-resolveOriginalSites(Context* c, Event* e, SiteRecordList* frozen,
-                     Site** sites)
+bool resolveOriginalSites(Context* c,
+                          Event* e,
+                          SiteRecordList* frozen,
+                          Site** sites)
 {
   bool complete = true;
   for (FrameIterator it(c, e->stackAfter, e->localsAfter, true);
-       it.hasMore();)
-  {
+       it.hasMore();) {
     FrameIterator::Element el = it.next(c);
     Value* v = el.value;
     Read* r = v ? live(c, v) : 0;
@@ -1502,12 +1583,16 @@ resolveOriginalSites(Context* c, Event* e, SiteRecordList* frozen,
         if (DebugControl) {
           char buffer[256];
           s->toString(c, buffer, 256);
-          fprintf(stderr, "resolve original %s for %p local %d frame %d\n",
-                  buffer, v, el.localIndex, el.frameIndex(c));
+          fprintf(stderr,
+                  "resolve original %s for %p local %d frame %d\n",
+                  buffer,
+                  v,
+                  el.localIndex,
+                  el.frameIndex(c));
         }
 
-        Site* target = pickSiteOrMove
-          (c, v, s->mask(c), true, true, ResolveRegisterReserveCount);
+        Site* target = pickSiteOrMove(
+            c, v, s->mask(c), true, true, ResolveRegisterReserveCount);
 
         freeze(c, frozen, target, v);
       } else {
@@ -1517,8 +1602,12 @@ resolveOriginalSites(Context* c, Event* e, SiteRecordList* frozen,
       if (DebugControl) {
         char buffer[256];
         s->toString(c, buffer, 256);
-        fprintf(stderr, "freeze original %s for %p local %d frame %d\n",
-                buffer, v, el.localIndex, el.frameIndex(c));
+        fprintf(stderr,
+                "freeze original %s for %p local %d frame %d\n",
+                buffer,
+                v,
+                el.localIndex,
+                el.frameIndex(c));
       }
 
       Value dummy(0, 0, ir::Type::addr());
@@ -1531,8 +1620,10 @@ resolveOriginalSites(Context* c, Event* e, SiteRecordList* frozen,
   return complete;
 }
 
-bool
-resolveSourceSites(Context* c, Event* e, SiteRecordList* frozen, Site** sites)
+bool resolveSourceSites(Context* c,
+                        Event* e,
+                        SiteRecordList* frozen,
+                        Site** sites)
 {
   bool complete = true;
   for (FrameIterator it(c, e->stackAfter, e->localsAfter); it.hasMore();) {
@@ -1542,16 +1633,22 @@ resolveSourceSites(Context* c, Event* e, SiteRecordList* frozen, Site** sites)
 
     if (r and sites[el.localIndex] == 0) {
       SiteMask mask((1 << lir::RegisterOperand) | (1 << lir::MemoryOperand),
-                    c->regFile->generalRegisters.mask, AnyFrameIndex);
+                    c->regFile->generalRegisters.mask,
+                    AnyFrameIndex);
 
-      Site* s = pickSourceSite
-        (c, r, 0, 0, &mask, true, false, true, acceptForResolve);
+      Site* s = pickSourceSite(
+          c, r, 0, 0, &mask, true, false, true, acceptForResolve);
 
       if (s) {
         if (DebugControl) {
-          char buffer[256]; s->toString(c, buffer, 256);
-          fprintf(stderr, "resolve source %s from %p local %d frame %d\n",
-                  buffer, v, el.localIndex, el.frameIndex(c));
+          char buffer[256];
+          s->toString(c, buffer, 256);
+          fprintf(stderr,
+                  "resolve source %s from %p local %d frame %d\n",
+                  buffer,
+                  v,
+                  el.localIndex,
+                  el.frameIndex(c));
         }
 
         freeze(c, frozen, s, v);
@@ -1566,8 +1663,10 @@ resolveSourceSites(Context* c, Event* e, SiteRecordList* frozen, Site** sites)
   return complete;
 }
 
-void
-resolveTargetSites(Context* c, Event* e, SiteRecordList* frozen, Site** sites)
+void resolveTargetSites(Context* c,
+                        Event* e,
+                        SiteRecordList* frozen,
+                        Site** sites)
 {
   for (FrameIterator it(c, e->stackAfter, e->localsAfter); it.hasMore();) {
     FrameIterator::Element el = it.next(c);
@@ -1576,10 +1675,11 @@ resolveTargetSites(Context* c, Event* e, SiteRecordList* frozen, Site** sites)
 
     if (r and sites[el.localIndex] == 0) {
       SiteMask mask((1 << lir::RegisterOperand) | (1 << lir::MemoryOperand),
-                    c->regFile->generalRegisters.mask, AnyFrameIndex);
+                    c->regFile->generalRegisters.mask,
+                    AnyFrameIndex);
 
-      Site* s = pickSourceSite
-        (c, r, 0, 0, &mask, false, true, true, acceptForResolve);
+      Site* s = pickSourceSite(
+          c, r, 0, 0, &mask, false, true, true, acceptForResolve);
 
       if (s == 0) {
         s = maybeMove(c, v, mask, false, true, ResolveRegisterReserveCount);
@@ -1590,16 +1690,20 @@ resolveTargetSites(Context* c, Event* e, SiteRecordList* frozen, Site** sites)
       sites[el.localIndex] = s->copy(c);
 
       if (DebugControl) {
-        char buffer[256]; sites[el.localIndex]->toString(c, buffer, 256);
-        fprintf(stderr, "resolve target %s for %p local %d frame %d\n",
-                buffer, el.value, el.localIndex, el.frameIndex(c));
+        char buffer[256];
+        sites[el.localIndex]->toString(c, buffer, 256);
+        fprintf(stderr,
+                "resolve target %s for %p local %d frame %d\n",
+                buffer,
+                el.value,
+                el.localIndex,
+                el.frameIndex(c));
       }
     }
   }
 }
 
-void
-resolveJunctionSites(Context* c, Event* e, SiteRecordList* frozen)
+void resolveJunctionSites(Context* c, Event* e, SiteRecordList* frozen)
 {
   bool complete;
   if (e->junctionSites) {
@@ -1618,29 +1722,28 @@ resolveJunctionSites(Context* c, Event* e, SiteRecordList* frozen)
     }
 
     if (DebugControl) {
-      fprintf(stderr, "resolved junction sites %p at %d\n",
-              e->junctionSites, e->logicalInstruction->index);
+      fprintf(stderr,
+              "resolved junction sites %p at %d\n",
+              e->junctionSites,
+              e->logicalInstruction->index);
     }
   }
 }
 
-void
-resolveBranchSites(Context* c, Event* e, SiteRecordList* frozen)
+void resolveBranchSites(Context* c, Event* e, SiteRecordList* frozen)
 {
   if (e->successors->nextSuccessor and e->junctionSites == 0) {
     unsigned footprint = frameFootprint(c, e->stackAfter);
     RUNTIME_ARRAY(Site*, branchSites, footprint);
     memset(RUNTIME_ARRAY_BODY(branchSites), 0, sizeof(Site*) * footprint);
 
-    if (not resolveSourceSites(c, e, frozen, RUNTIME_ARRAY_BODY(branchSites)))
-    {
+    if (not resolveSourceSites(c, e, frozen, RUNTIME_ARRAY_BODY(branchSites))) {
       resolveTargetSites(c, e, frozen, RUNTIME_ARRAY_BODY(branchSites));
     }
   }
 }
 
-void
-captureBranchSnapshots(Context* c, Event* e)
+void captureBranchSnapshots(Context* c, Event* e)
 {
   if (e->successors->nextSuccessor) {
     for (FrameIterator it(c, e->stackAfter, e->localsAfter); it.hasMore();) {
@@ -1648,27 +1751,28 @@ captureBranchSnapshots(Context* c, Event* e)
       e->snapshots = makeSnapshots(c, el.value, e->snapshots);
     }
 
-    for (List<Value*>* sv = e->successors->forkState->saved; sv; sv = sv->next) {
+    for (List<Value*>* sv = e->successors->forkState->saved; sv;
+         sv = sv->next) {
       e->snapshots = makeSnapshots(c, sv->item, e->snapshots);
     }
 
     if (DebugControl) {
-      fprintf(stderr, "captured snapshots %p at %d\n",
-              e->snapshots, e->logicalInstruction->index);
+      fprintf(stderr,
+              "captured snapshots %p at %d\n",
+              e->snapshots,
+              e->logicalInstruction->index);
     }
   }
 }
 
-void
-populateSiteTables(Context* c, Event* e, SiteRecordList* frozen)
+void populateSiteTables(Context* c, Event* e, SiteRecordList* frozen)
 {
   resolveJunctionSites(c, e, frozen);
 
   resolveBranchSites(c, e, frozen);
 }
 
-void
-setSites(Context* c, Value* v, Site* s)
+void setSites(Context* c, Value* v, Site* s)
 {
   assertT(c, live(c, v));
 
@@ -1677,13 +1781,13 @@ setSites(Context* c, Value* v, Site* s)
   }
 
   if (DebugControl) {
-    char buffer[256]; sitesToString(c, v->sites, buffer, 256);
+    char buffer[256];
+    sitesToString(c, v->sites, buffer, 256);
     fprintf(stderr, "set sites %s for %p\n", buffer, v);
   }
 }
 
-void
-resetFrame(Context* c, Event* e)
+void resetFrame(Context* c, Event* e)
 {
   for (FrameIterator it(c, e->stackBefore, e->localsBefore); it.hasMore();) {
     FrameIterator::Element el = it.next(c);
@@ -1695,8 +1799,7 @@ resetFrame(Context* c, Event* e)
   }
 }
 
-void
-setSites(Context* c, Event* e, Site** sites)
+void setSites(Context* c, Event* e, Site** sites)
 {
   resetFrame(c, e);
 
@@ -1706,19 +1809,26 @@ setSites(Context* c, Event* e, Site** sites)
       if (live(c, el.value)) {
         setSites(c, el.value, sites[el.localIndex]);
       } else if (DebugControl) {
-        char buffer[256]; sitesToString(c, sites[el.localIndex], buffer, 256);
-        fprintf(stderr, "skip sites %s for %p local %d frame %d\n",
-                buffer, el.value, el.localIndex, el.frameIndex(c));
+        char buffer[256];
+        sitesToString(c, sites[el.localIndex], buffer, 256);
+        fprintf(stderr,
+                "skip sites %s for %p local %d frame %d\n",
+                buffer,
+                el.value,
+                el.localIndex,
+                el.frameIndex(c));
       }
     } else if (DebugControl) {
-      fprintf(stderr, "no sites for %p local %d frame %d\n",
-              el.value, el.localIndex, el.frameIndex(c));
+      fprintf(stderr,
+              "no sites for %p local %d frame %d\n",
+              el.value,
+              el.localIndex,
+              el.frameIndex(c));
     }
   }
 }
 
-void
-removeBuddies(Context* c)
+void removeBuddies(Context* c)
 {
   for (FrameIterator it(c, c->stack, c->locals); it.hasMore();) {
     FrameIterator::Element el = it.next(c);
@@ -1726,8 +1836,7 @@ removeBuddies(Context* c)
   }
 }
 
-void
-restore(Context* c, Event* e, Snapshot* snapshots)
+void restore(Context* c, Event* e, Snapshot* snapshots)
 {
   for (Snapshot* s = snapshots; s; s = s->next) {
     Value* v = s->value;
@@ -1735,7 +1844,8 @@ restore(Context* c, Event* e, Snapshot* snapshots)
     if (v != next) {
       v->buddy = v;
       Value* p = next;
-      while (p->buddy != v) p = p->buddy;
+      while (p->buddy != v)
+        p = p->buddy;
       p->buddy = next;
     }
   }
@@ -1761,8 +1871,7 @@ restore(Context* c, Event* e, Snapshot* snapshots)
   }
 }
 
-void
-populateSources(Context* c, Event* e)
+void populateSources(Context* c, Event* e)
 {
   RUNTIME_ARRAY(SiteRecord, frozenRecords, e->readCount);
   SiteRecordList frozen(RUNTIME_ARRAY_BODY(frozenRecords), e->readCount);
@@ -1771,9 +1880,9 @@ populateSources(Context* c, Event* e)
     r->value->source = readSource(c, r);
     if (r->value->source) {
       if (DebugReads) {
-        char buffer[256]; r->value->source->toString(c, buffer, 256);
-        fprintf(stderr, "freeze source %s for %p\n",
-                buffer, r->value);
+        char buffer[256];
+        r->value->source->toString(c, buffer, 256);
+        fprintf(stderr, "freeze source %s for %p\n", buffer, r->value);
       }
 
       freeze(c, &frozen, r->value->source, r->value);
@@ -1783,15 +1892,15 @@ populateSources(Context* c, Event* e)
   thaw(c, &frozen);
 }
 
-void
-setStubRead(Context* c, StubReadPair* p, Value* v)
+void setStubRead(Context* c, StubReadPair* p, Value* v)
 {
   if (v) {
     StubRead* r = stubRead(c);
     if (DebugReads) {
       fprintf(stderr, "add stub read %p to %p\n", r, v);
     }
-    // TODO: this is rather icky looking... but despite how it looks, it will not cause an NPE
+    // TODO: this is rather icky looking... but despite how it looks, it will
+    // not cause an NPE
     ((Event*)0)->addRead(c, v, r);
 
     p->value = v;
@@ -1799,14 +1908,12 @@ setStubRead(Context* c, StubReadPair* p, Value* v)
   }
 }
 
-void
-populateJunctionReads(Context* c, Link* link)
+void populateJunctionReads(Context* c, Link* link)
 {
-  JunctionState* state = new
-    (c->zone->allocate
-     (sizeof(JunctionState)
-      + (sizeof(StubReadPair) * frameFootprint(c, c->stack))))
-    JunctionState(frameFootprint(c, c->stack));
+  JunctionState* state = new (
+      c->zone->allocate(sizeof(JunctionState)
+                        + (sizeof(StubReadPair) * frameFootprint(c, c->stack))))
+      JunctionState(frameFootprint(c, c->stack));
 
   memset(state->reads, 0, sizeof(StubReadPair) * frameFootprint(c, c->stack));
 
@@ -1818,8 +1925,7 @@ populateJunctionReads(Context* c, Link* link)
   }
 }
 
-void
-updateJunctionReads(Context* c, JunctionState* state)
+void updateJunctionReads(Context* c, JunctionState* state)
 {
   for (FrameIterator it(c, c->stack, c->locals); it.hasMore();) {
     FrameIterator::Element e = it.next(c);
@@ -1828,8 +1934,8 @@ updateJunctionReads(Context* c, JunctionState* state)
       Read* r = live(c, e.value);
       if (r) {
         if (DebugReads) {
-          fprintf(stderr, "stub read %p for %p valid: %p\n",
-                  p->read, p->value, r);
+          fprintf(
+              stderr, "stub read %p for %p valid: %p\n", p->read, p->value, r);
         }
         p->read->read = r;
       }
@@ -1847,8 +1953,9 @@ updateJunctionReads(Context* c, JunctionState* state)
   }
 }
 
-void
-compile(Context* c, uintptr_t stackOverflowHandler, unsigned stackLimitOffset)
+void compile(Context* c,
+             uintptr_t stackOverflowHandler,
+             unsigned stackLimitOffset)
 {
   if (c->logicalCode[c->logicalIp]->lastEvent == 0) {
     appendDummy(c);
@@ -1869,7 +1976,8 @@ compile(Context* c, uintptr_t stackOverflowHandler, unsigned stackLimitOffset)
     if (DebugCompile) {
       fprintf(stderr,
               " -- compile %s at %d with %d preds %d succs %d stack\n",
-              e->name(), e->logicalInstruction->index,
+              e->name(),
+              e->logicalInstruction->index,
               e->predecessors->countPredecessors(),
               e->successors->countSuccessors(),
               e->stackBefore ? e->stackBefore->index + 1 : 0);
@@ -1889,24 +1997,26 @@ compile(Context* c, uintptr_t stackOverflowHandler, unsigned stackLimitOffset)
 
       Event* first = e->predecessors->predecessor;
       if (e->predecessors->nextPredecessor) {
-        for (Link* pl = e->predecessors;
-             pl->nextPredecessor;
-             pl = pl->nextPredecessor)
-        {
+        for (Link* pl = e->predecessors; pl->nextPredecessor;
+             pl = pl->nextPredecessor) {
           updateJunctionReads(c, pl->junctionState);
         }
 
         if (DebugControl) {
-          fprintf(stderr, "set sites to junction sites %p at %d\n",
-                  first->junctionSites, first->logicalInstruction->index);
+          fprintf(stderr,
+                  "set sites to junction sites %p at %d\n",
+                  first->junctionSites,
+                  first->logicalInstruction->index);
         }
 
         setSites(c, e, first->junctionSites);
         removeBuddies(c);
       } else if (first->successors->nextSuccessor) {
         if (DebugControl) {
-          fprintf(stderr, "restore snapshots %p at %d\n",
-                  first->snapshots, first->logicalInstruction->index);
+          fprintf(stderr,
+                  "restore snapshots %p at %d\n",
+                  first->snapshots,
+                  first->logicalInstruction->index);
         }
 
         restore(c, e, first->snapshots);
@@ -1939,7 +2049,8 @@ compile(Context* c, uintptr_t stackOverflowHandler, unsigned stackLimitOffset)
     }
 
     if (e->visitLinks) {
-      for (List<Link*>* cell = reverseDestroy(e->visitLinks); cell; cell = cell->next) {
+      for (List<Link*>* cell = reverseDestroy(e->visitLinks); cell;
+           cell = cell->next) {
         visit(c, cell->item);
       }
       e->visitLinks = 0;
@@ -1948,15 +2059,13 @@ compile(Context* c, uintptr_t stackOverflowHandler, unsigned stackLimitOffset)
     for (CodePromise* p = e->promises; p; p = p->next) {
       p->offset = a->offset();
     }
-    
+
     a->endEvent();
 
     LogicalInstruction* nextInstruction = e->logicalInstruction->next(c);
-    if (e->next == 0
-        or (e->next->logicalInstruction != e->logicalInstruction
-            and (e->next->logicalInstruction != nextInstruction
-                 or e != e->logicalInstruction->lastEvent)))
-    {
+    if (e->next == 0 or (e->next->logicalInstruction != e->logicalInstruction
+                         and (e->next->logicalInstruction != nextInstruction
+                              or e != e->logicalInstruction->lastEvent))) {
       Block* b = e->logicalInstruction->firstEvent->block;
 
       while (b->nextBlock) {
@@ -1979,8 +2088,7 @@ compile(Context* c, uintptr_t stackOverflowHandler, unsigned stackLimitOffset)
   c->firstBlock = firstBlock;
 }
 
-void
-restore(Context* c, ForkState* state)
+void restore(Context* c, ForkState* state)
 {
   for (unsigned i = 0; i < state->readCount; ++i) {
     ForkElement* p = state->elements + i;
@@ -1989,14 +2097,14 @@ restore(Context* c, ForkState* state)
   }
 }
 
-void
-addForkElement(Context* c, Value* v, ForkState* state, unsigned index)
+void addForkElement(Context* c, Value* v, ForkState* state, unsigned index)
 {
   MultiRead* r = multiRead(c);
   if (DebugReads) {
     fprintf(stderr, "add multi read %p to %p\n", r, v);
   }
-  // TODO: this is rather icky looking... but despite how it looks, it will not cause an NPE
+  // TODO: this is rather icky looking... but despite how it looks, it will not
+  // cause an NPE
   ((Event*)0)->addRead(c, v, r);
 
   ForkElement* p = state->elements + index;
@@ -2004,8 +2112,7 @@ addForkElement(Context* c, Value* v, ForkState* state, unsigned index)
   p->read = r;
 }
 
-ForkState*
-saveState(Context* c)
+ForkState* saveState(Context* c)
 {
   if (c->logicalCode[c->logicalIp]->lastEvent == 0) {
     appendDummy(c);
@@ -2013,10 +2120,9 @@ saveState(Context* c)
 
   unsigned elementCount = frameFootprint(c, c->stack) + c->saved->count();
 
-  ForkState* state = new
-    (c->zone->allocate
-     (sizeof(ForkState) + (sizeof(ForkElement) * elementCount)))
-    ForkState(c->stack, c->locals, c->saved, c->predecessor, c->logicalIp);
+  ForkState* state = new (c->zone->allocate(
+      sizeof(ForkState) + (sizeof(ForkElement) * elementCount)))
+      ForkState(c->stack, c->locals, c->saved, c->predecessor, c->logicalIp);
 
   if (c->predecessor) {
     c->forkState = state;
@@ -2040,8 +2146,7 @@ saveState(Context* c)
   return state;
 }
 
-void
-restoreState(Context* c, ForkState* s)
+void restoreState(Context* c, ForkState* s)
 {
   if (c->logicalCode[c->logicalIp]->lastEvent == 0) {
     appendDummy(c);
@@ -2058,8 +2163,7 @@ restoreState(Context* c, ForkState* s)
   }
 }
 
-Value*
-maybeBuddy(Context* c, Value* v)
+Value* maybeBuddy(Context* c, Value* v)
 {
   if (v->home >= 0) {
     Value* n = value(c, v->type);
@@ -2070,8 +2174,7 @@ maybeBuddy(Context* c, Value* v)
   }
 }
 
-void
-linkLocals(Context* c, Local* oldLocals, Local* newLocals)
+void linkLocals(Context* c, Local* oldLocals, Local* newLocals)
 {
   for (int i = 0; i < static_cast<int>(c->localFootprint); ++i) {
     Local* local = oldLocals + i;
@@ -2080,8 +2183,7 @@ linkLocals(Context* c, Local* oldLocals, Local* newLocals)
 
       if (i + highOffset >= 0
           and i + highOffset < static_cast<int>(c->localFootprint)
-          and local->value->nextWord == local[highOffset].value)
-      {
+          and local->value->nextWord == local[highOffset].value) {
         Value* v = newLocals[i].value;
         Value* next = newLocals[i + highOffset].value;
         v->nextWord = next;
@@ -2092,11 +2194,14 @@ linkLocals(Context* c, Local* oldLocals, Local* newLocals)
   }
 }
 
-class Client: public Assembler::Client {
+class Client : public Assembler::Client {
  public:
-  Client(Context* c): c(c) { }
+  Client(Context* c) : c(c)
+  {
+  }
 
-  virtual int acquireTemporary(uint32_t mask) {
+  virtual int acquireTemporary(uint32_t mask)
+  {
     unsigned cost;
     int r = pickRegisterTarget(c, 0, mask, &cost);
     expect(c, cost < Target::Impossible);
@@ -2105,11 +2210,13 @@ class Client: public Assembler::Client {
     return r;
   }
 
-  virtual void releaseTemporary(int r) {
+  virtual void releaseTemporary(int r)
+  {
     c->registerResources[r].decrement(c);
   }
 
-  virtual void save(int r) {
+  virtual void save(int r)
+  {
     RegisterResource* reg = c->registerResources + r;
 
     assertT(c, reg->referenceCount == 0);
@@ -2124,27 +2231,33 @@ class Client: public Assembler::Client {
   Context* c;
 };
 
-class MyCompiler: public Compiler {
+class MyCompiler : public Compiler {
  public:
-  MyCompiler(System* s, Assembler* assembler, Zone* zone,
-             Compiler::Client* compilerClient):
-    c(s, assembler, zone, compilerClient), client(&c)
+  MyCompiler(System* s,
+             Assembler* assembler,
+             Zone* zone,
+             Compiler::Client* compilerClient)
+      : c(s, assembler, zone, compilerClient), client(&c)
   {
     assembler->setClient(&client);
   }
 
-  virtual State* saveState() {
+  virtual State* saveState()
+  {
     State* s = compiler::saveState(&c);
     restoreState(s);
     return s;
   }
 
-  virtual void restoreState(State* state) {
+  virtual void restoreState(State* state)
+  {
     compiler::restoreState(&c, static_cast<ForkState*>(state));
   }
 
-  virtual void init(unsigned logicalCodeLength, unsigned parameterFootprint,
-                    unsigned localFootprint, unsigned alignedFrameSize)
+  virtual void init(unsigned logicalCodeLength,
+                    unsigned parameterFootprint,
+                    unsigned localFootprint,
+                    unsigned alignedFrameSize)
   {
     c.parameterFootprint = parameterFootprint;
     c.localFootprint = localFootprint;
@@ -2152,9 +2265,9 @@ class MyCompiler: public Compiler {
 
     unsigned frameResourceCount = totalFrameSize(&c);
 
-    c.frameResources = static_cast<FrameResource*>
-      (c.zone->allocate(sizeof(FrameResource) * frameResourceCount));
-    
+    c.frameResources = static_cast<FrameResource*>(
+        c.zone->allocate(sizeof(FrameResource) * frameResourceCount));
+
     for (unsigned i = 0; i < frameResourceCount; ++i) {
       new (c.frameResources + i) FrameResource;
     }
@@ -2162,14 +2275,14 @@ class MyCompiler: public Compiler {
     unsigned base = frameBase(&c);
     c.frameResources[base + c.arch->returnAddressOffset()].reserved = true;
     c.frameResources[base + c.arch->framePointerOffset()].reserved
-      = UseFramePointer;
+        = UseFramePointer;
 
     c.logicalCode.init(c.zone, logicalCodeLength);
 
     c.logicalCode[-1] = new (c.zone) LogicalInstruction(-1, c.stack, c.locals);
 
-    c.locals = static_cast<Local*>
-      (c.zone->allocate(sizeof(Local) * localFootprint));
+    c.locals
+        = static_cast<Local*>(c.zone->allocate(sizeof(Local) * localFootprint));
 
     memset(c.locals, 0, sizeof(Local) * localFootprint);
   }
@@ -2179,7 +2292,8 @@ class MyCompiler: public Compiler {
     c.logicalCode.extend(c.zone, more);
   }
 
-  virtual void visitLogicalIp(unsigned logicalIp) {
+  virtual void visitLogicalIp(unsigned logicalIp)
+  {
     assertT(&c, logicalIp < c.logicalCode.count());
 
     if (c.logicalCode[c.logicalIp]->lastEvent == 0) {
@@ -2191,22 +2305,26 @@ class MyCompiler: public Compiler {
     Event* p = c.predecessor;
     if (p) {
       if (DebugAppend) {
-        fprintf(stderr, "visit %d pred %d\n", logicalIp,
+        fprintf(stderr,
+                "visit %d pred %d\n",
+                logicalIp,
                 p->logicalInstruction->index);
       }
 
       p->stackAfter = c.stack;
       p->localsAfter = c.locals;
 
-      Link* link = compiler::link
-        (&c, p, e->predecessors, e, p->successors, c.forkState);
+      Link* link = compiler::link(
+          &c, p, e->predecessors, e, p->successors, c.forkState);
       e->predecessors = link;
       p->successors = link;
       c.lastEvent->visitLinks = cons(&c, link, c.lastEvent->visitLinks);
 
       if (DebugAppend) {
-        fprintf(stderr, "populate junction reads for %d to %d\n",
-                p->logicalInstruction->index, logicalIp);
+        fprintf(stderr,
+                "populate junction reads for %d to %d\n",
+                p->logicalInstruction->index,
+                logicalIp);
       }
 
       populateJunctionReads(&c, link);
@@ -2215,7 +2333,8 @@ class MyCompiler: public Compiler {
     c.forkState = 0;
   }
 
-  virtual void startLogicalIp(unsigned logicalIp) {
+  virtual void startLogicalIp(unsigned logicalIp)
+  {
     assertT(&c, logicalIp < c.logicalCode.count());
     assertT(&c, c.logicalCode[logicalIp] == 0);
 
@@ -2229,20 +2348,24 @@ class MyCompiler: public Compiler {
       p->localsAfter = c.locals;
     }
 
-    c.logicalCode[logicalIp] = new(c.zone) LogicalInstruction(logicalIp, c.stack, c.locals);
+    c.logicalCode[logicalIp] = new (c.zone)
+        LogicalInstruction(logicalIp, c.stack, c.locals);
 
     c.logicalIp = logicalIp;
   }
 
-  virtual Promise* machineIp(unsigned logicalIp) {
+  virtual Promise* machineIp(unsigned logicalIp)
+  {
     return ipPromise(&c, logicalIp);
   }
 
-  virtual Promise* poolAppend(intptr_t value) {
+  virtual Promise* poolAppend(intptr_t value)
+  {
     return poolAppendPromise(resolvedPromise(&c, value));
   }
 
-  virtual Promise* poolAppendPromise(Promise* value) {
+  virtual Promise* poolAppendPromise(Promise* value)
+  {
     Promise* p = poolPromise(&c, c.constantCount);
 
     ConstantPoolNode* constant = new (c.zone) ConstantPoolNode(value);
@@ -2253,7 +2376,7 @@ class MyCompiler: public Compiler {
       c.firstConstant = constant;
     }
     c.lastConstant = constant;
-    ++ c.constantCount;
+    ++c.constantCount;
 
     return p;
   }
@@ -2295,7 +2418,8 @@ class MyCompiler: public Compiler {
     return compiler::threadRegister(&c);
   }
 
-  Promise* machineIp() {
+  Promise* machineIp()
+  {
     return c.logicalCode[c.logicalIp]->lastEvent->makeCodePromise(&c);
   }
 
@@ -2334,28 +2458,31 @@ class MyCompiler: public Compiler {
   virtual void pushed(ir::Type type)
   {
     Value* v = value(&c, type);
-    appendFrameSite
-      (&c, v, frameIndex
-       (&c, (c.stack ? c.stack->index : 0) + c.localFootprint));
+    appendFrameSite(
+        &c,
+        v,
+        frameIndex(&c, (c.stack ? c.stack->index : 0) + c.localFootprint));
 
     Stack* s = compiler::stack(&c, v, c.stack);
     v->home = frameIndex(&c, s->index + c.localFootprint);
     c.stack = s;
   }
 
-  virtual void popped(unsigned footprint) {
-    for (; footprint; -- footprint) {
+  virtual void popped(unsigned footprint)
+  {
+    for (; footprint; --footprint) {
       assertT(&c, c.stack->value == 0 or c.stack->value->home >= 0);
 
       if (DebugFrame) {
         fprintf(stderr, "popped %p\n", c.stack->value);
       }
-      
+
       c.stack = c.stack->next;
     }
   }
 
-  virtual unsigned topOfStack() {
+  virtual unsigned topOfStack()
+  {
     return c.stack->index;
   }
 
@@ -2387,7 +2514,7 @@ class MyCompiler: public Compiler {
           (TargetBytesPerWord == 8 and low->value->nextWord == low->value
            and high->value == 0)
           or (TargetBytesPerWord == 4 and low->value->nextWord == high->value));
-#endif // not NDEBUG
+#endif  // not NDEBUG
 
       if (bigEndian) {
         s = s->next;
@@ -2404,7 +2531,8 @@ class MyCompiler: public Compiler {
                           unsigned argumentCount,
                           ...)
   {
-    va_list a; va_start(a, argumentCount);
+    va_list a;
+    va_start(a, argumentCount);
 
     bool bigEndian = c.arch->bigEndian();
 
@@ -2423,11 +2551,11 @@ class MyCompiler: public Compiler {
           RUNTIME_ARRAY_BODY(arguments)[++index] = o->nextWord;
         }
         size = TargetBytesPerWord;
-        ++ index;
+        ++index;
       } else {
         size = 8;
       }
-      ++ footprint;
+      ++footprint;
     }
 
     va_end(a);
@@ -2526,8 +2654,11 @@ class MyCompiler: public Compiler {
     }
 
     if (DebugFrame) {
-      fprintf(stderr, "init local %p at %d (%d)\n",
-              v, index, frameIndex(&c, index));
+      fprintf(stderr,
+              "init local %p at %d (%d)\n",
+              v,
+              index,
+              frameIndex(&c, index));
     }
 
     appendFrameSite(&c, v, frameIndex(&c, index));
@@ -2537,7 +2668,8 @@ class MyCompiler: public Compiler {
     v->home = frameIndex(&c, index);
   }
 
-  virtual void initLocalsFromLogicalIp(unsigned logicalIp) {
+  virtual void initLocalsFromLogicalIp(unsigned logicalIp)
+  {
     assertT(&c, logicalIp < c.logicalCode.count());
 
     unsigned footprint = sizeof(Local) * c.localFootprint;
@@ -2558,7 +2690,11 @@ class MyCompiler: public Compiler {
 
   virtual void storeLocal(ir::Value* src, unsigned index)
   {
-    compiler::storeLocal(&c, typeFootprint(&c, src->type), static_cast<Value*>(src), index, true);
+    compiler::storeLocal(&c,
+                         typeFootprint(&c, src->type),
+                         static_cast<Value*>(src),
+                         index,
+                         true);
   }
 
   virtual ir::Value* loadLocal(ir::Type type, unsigned index)
@@ -2566,7 +2702,8 @@ class MyCompiler: public Compiler {
     return compiler::loadLocal(&c, type, index);
   }
 
-  virtual void saveLocals() {
+  virtual void saveLocals()
+  {
     int oldIp UNUSED = c.logicalIp;
     appendSaveLocals(&c);
     assertT(&c, oldIp == c.logicalIp);
@@ -2577,8 +2714,11 @@ class MyCompiler: public Compiler {
                            ir::Value* index,
                            intptr_t handler)
   {
-    appendBoundsCheck(&c, static_cast<Value*>(object), lengthOffset,
-                      static_cast<Value*>(index), handler);
+    appendBoundsCheck(&c,
+                      static_cast<Value*>(object),
+                      lengthOffset,
+                      static_cast<Value*>(index),
+                      handler);
   }
 
   virtual ir::Value* truncate(ir::Type type, ir::Value* src)
@@ -2687,23 +2827,18 @@ class MyCompiler: public Compiler {
 
     Value* result = value(&c, type);
 
-    appendCombine(&c,
-                  op,
-                  static_cast<Value*>(a),
-                  static_cast<Value*>(b),
-                  result);
+    appendCombine(
+        &c, op, static_cast<Value*>(a), static_cast<Value*>(b), result);
     return result;
   }
 
-  virtual ir::Value* unaryOp(lir::BinaryOperation op,
-                             ir::Value* a)
+  virtual ir::Value* unaryOp(lir::BinaryOperation op, ir::Value* a)
   {
     assertT(&c,
             (isGeneralUnaryOp(op) and isGeneralValue(a))
             or (isFloatUnaryOp(op) and isFloatValue(a)));
     Value* result = value(&c, a->type);
-    appendTranslate(
-        &c, op, static_cast<Value*>(a), result);
+    appendTranslate(&c, op, static_cast<Value*>(a), result);
     return result;
   }
 
@@ -2712,10 +2847,7 @@ class MyCompiler: public Compiler {
     assertT(&c, isFloatValue(a));
     assertT(&c, resType.flavor() == ir::Type::Float);
     Value* result = value(&c, resType);
-    appendTranslate(&c,
-                    lir::Float2Float,
-                    static_cast<Value*>(a),
-                    result);
+    appendTranslate(&c, lir::Float2Float, static_cast<Value*>(a), result);
     return result;
   }
 
@@ -2724,10 +2856,7 @@ class MyCompiler: public Compiler {
     assertT(&c, isFloatValue(a));
     assertT(&c, resType.flavor() != ir::Type::Float);
     Value* result = value(&c, resType);
-    appendTranslate(&c,
-                    lir::Float2Int,
-                    static_cast<Value*>(a),
-                    result);
+    appendTranslate(&c, lir::Float2Int, static_cast<Value*>(a), result);
     return result;
   }
 
@@ -2736,10 +2865,7 @@ class MyCompiler: public Compiler {
     assertT(&c, isGeneralValue(a));
     assertT(&c, resType.flavor() == ir::Type::Float);
     Value* result = value(&c, resType);
-    appendTranslate(&c,
-                    lir::Int2Float,
-                    static_cast<Value*>(a),
-                    result);
+    appendTranslate(&c, lir::Int2Float, static_cast<Value*>(a), result);
     return result;
   }
 
@@ -2754,48 +2880,55 @@ class MyCompiler: public Compiler {
     compiler::compile(&c, stackOverflowHandler, stackLimitOffset);
   }
 
-  virtual unsigned resolve(uint8_t* dst) {
+  virtual unsigned resolve(uint8_t* dst)
+  {
     c.machineCode = dst;
     c.assembler->setDestination(dst);
 
     Block* block = c.firstBlock;
     while (block->nextBlock or block->nextInstruction) {
       Block* next = block->nextBlock
-        ? block->nextBlock
-        : block->nextInstruction->firstEvent->block;
+                        ? block->nextBlock
+                        : block->nextInstruction->firstEvent->block;
 
-      next->start = block->assemblerBlock->resolve
-        (block->start, next->assemblerBlock);
+      next->start
+          = block->assemblerBlock->resolve(block->start, next->assemblerBlock);
 
       block = next;
     }
 
-    return c.machineCodeSize = block->assemblerBlock->resolve
-      (block->start, 0) + c.assembler->footerSize();
+    return c.machineCodeSize = block->assemblerBlock->resolve(block->start, 0)
+                               + c.assembler->footerSize();
   }
 
-  virtual unsigned poolSize() {
+  virtual unsigned poolSize()
+  {
     return c.constantCount * TargetBytesPerWord;
   }
 
-  virtual void write() {
+  virtual void write()
+  {
     c.assembler->write();
 
     int i = 0;
     for (ConstantPoolNode* n = c.firstConstant; n; n = n->next) {
-      target_intptr_t* target = reinterpret_cast<target_intptr_t*>
-        (c.machineCode + pad(c.machineCodeSize, TargetBytesPerWord) + i);
+      target_intptr_t* target = reinterpret_cast<target_intptr_t*>(
+          c.machineCode + pad(c.machineCodeSize, TargetBytesPerWord) + i);
 
       if (n->promise->resolved()) {
         *target = targetVW(n->promise->value());
       } else {
-        class Listener: public Promise::Listener {
+        class Listener : public Promise::Listener {
          public:
-          Listener(target_intptr_t* target): target(target){ }
+          Listener(target_intptr_t* target) : target(target)
+          {
+          }
 
-          virtual bool resolve(int64_t value, void** location) {
+          virtual bool resolve(int64_t value, void** location)
+          {
             *target = targetVW(value);
-            if (location) *location = target;
+            if (location)
+              *location = target;
             return true;
           }
 
@@ -2808,7 +2941,8 @@ class MyCompiler: public Compiler {
     }
   }
 
-  virtual void dispose() {
+  virtual void dispose()
+  {
     // ignore
   }
 
@@ -2816,14 +2950,15 @@ class MyCompiler: public Compiler {
   compiler::Client client;
 };
 
-} // namespace compiler
+}  // namespace compiler
 
-Compiler*
-makeCompiler(System* system, Assembler* assembler, Zone* zone,
-             Compiler::Client* client)
+Compiler* makeCompiler(System* system,
+                       Assembler* assembler,
+                       Zone* zone,
+                       Compiler::Client* client)
 {
-  return new(zone) compiler::MyCompiler(system, assembler, zone, client);
+  return new (zone) compiler::MyCompiler(system, assembler, zone, client);
 }
 
-} // namespace codegen
-} // namespace avian
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/compiler/context.cpp b/src/codegen/compiler/context.cpp
index 404b9aba28..c7b7a51741 100644
--- a/src/codegen/compiler/context.cpp
+++ b/src/codegen/compiler/context.cpp
@@ -53,18 +53,22 @@ Context::Context(vm::System* system,
                                     - regFile->generalRegisters.start),
       targetInfo(arch->targetInfo())
 {
-  for (unsigned i = regFile->generalRegisters.start; i < regFile->generalRegisters.limit; ++i) {
+  for (unsigned i = regFile->generalRegisters.start;
+       i < regFile->generalRegisters.limit;
+       ++i) {
     new (registerResources + i) RegisterResource(arch->reserved(i));
 
     if (registerResources[i].reserved) {
-      -- availableGeneralRegisterCount;
+      --availableGeneralRegisterCount;
     }
   }
-  for (unsigned i = regFile->floatRegisters.start; i < regFile->floatRegisters.limit; ++i) {
+  for (unsigned i = regFile->floatRegisters.start;
+       i < regFile->floatRegisters.limit;
+       ++i) {
     new (registerResources + i) RegisterResource(arch->reserved(i));
   }
 }
 
-} // namespace compiler
-} // namespace codegen
-} // namespace avian
+}  // namespace compiler
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/compiler/context.h b/src/codegen/compiler/context.h
index 22cb043ee7..82488858a2 100644
--- a/src/codegen/compiler/context.h
+++ b/src/codegen/compiler/context.h
@@ -37,8 +37,9 @@ class ConstantPoolNode;
 class ForkState;
 class Block;
 
-template<class T>
-List<T>* reverseDestroy(List<T>* cell) {
+template <class T>
+List<T>* reverseDestroy(List<T>* cell)
+{
   List<T>* previous = 0;
   while (cell) {
     List<T>* next = cell->next;
@@ -93,7 +94,9 @@ class LogicalCode {
 
 class Context {
  public:
-  Context(vm::System* system, Assembler* assembler, vm::Zone* zone,
+  Context(vm::System* system,
+          Assembler* assembler,
+          vm::Zone* zone,
           Compiler::Client* client);
 
   vm::System* system;
@@ -128,17 +131,19 @@ class Context {
   ir::TargetInfo targetInfo;
 };
 
-inline Aborter* getAborter(Context* c) {
+inline Aborter* getAborter(Context* c)
+{
   return c->system;
 }
 
-template<class T>
-List<T>* cons(Context* c, const T& value, List<T>* next) {
+template <class T>
+List<T>* cons(Context* c, const T& value, List<T>* next)
+{
   return new (c->zone) List<T>(value, next);
 }
 
-} // namespace compiler
-} // namespace codegen
-} // namespace avian
+}  // namespace compiler
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_COMPILER_CONTEXT_H
+#endif  // AVIAN_CODEGEN_COMPILER_CONTEXT_H
diff --git a/src/codegen/compiler/event.cpp b/src/codegen/compiler/event.cpp
index 30cde104a0..b4433da9cf 100644
--- a/src/codegen/compiler/event.cpp
+++ b/src/codegen/compiler/event.cpp
@@ -34,27 +34,41 @@ CodePromise* codePromise(Context* c, Promise* offset);
 
 void saveLocals(Context* c, Event* e);
 
-void
-apply(Context* c, lir::UnaryOperation op,
-      unsigned s1Size, Site* s1Low, Site* s1High);
+void apply(Context* c,
+           lir::UnaryOperation op,
+           unsigned s1Size,
+           Site* s1Low,
+           Site* s1High);
 
-void
-apply(Context* c, lir::BinaryOperation op,
-      unsigned s1Size, Site* s1Low, Site* s1High,
-      unsigned s2Size, Site* s2Low, Site* s2High);
-
-void
-apply(Context* c, lir::TernaryOperation op,
-      unsigned s1Size, Site* s1Low, Site* s1High,
-      unsigned s2Size, Site* s2Low, Site* s2High,
-      unsigned s3Size, Site* s3Low, Site* s3High);
+void apply(Context* c,
+           lir::BinaryOperation op,
+           unsigned s1Size,
+           Site* s1Low,
+           Site* s1High,
+           unsigned s2Size,
+           Site* s2Low,
+           Site* s2High);
 
+void apply(Context* c,
+           lir::TernaryOperation op,
+           unsigned s1Size,
+           Site* s1Low,
+           Site* s1High,
+           unsigned s2Size,
+           Site* s2Low,
+           Site* s2High,
+           unsigned s3Size,
+           Site* s3Low,
+           Site* s3High);
 
 void append(Context* c, Event* e);
 
-
-void clean(Context* c, Event* e, Stack* stack, Local* locals, Read* reads,
-      unsigned popIndex);
+void clean(Context* c,
+           Event* e,
+           Stack* stack,
+           Local* locals,
+           Read* reads,
+           unsigned popIndex);
 
 Read* live(Context* c UNUSED, Value* v);
 
@@ -69,35 +83,60 @@ void maybeMove(Context* c,
                Value* dst,
                const SiteMask& dstMask);
 
-Site*
-maybeMove(Context* c, Value* v, const SiteMask& mask, bool intersectMask,
-          bool includeNextWord, unsigned registerReserveCount = 0);
+Site* maybeMove(Context* c,
+                Value* v,
+                const SiteMask& mask,
+                bool intersectMask,
+                bool includeNextWord,
+                unsigned registerReserveCount = 0);
 
-Site*
-maybeMove(Context* c, Read* read, bool intersectRead, bool includeNextWord,
-          unsigned registerReserveCount = 0);
-Site*
-pickSiteOrMove(Context* c, Value* src, Value* dst, Site* nextWord,
-               unsigned index);
+Site* maybeMove(Context* c,
+                Read* read,
+                bool intersectRead,
+                bool includeNextWord,
+                unsigned registerReserveCount = 0);
+Site* pickSiteOrMove(Context* c,
+                     Value* src,
+                     Value* dst,
+                     Site* nextWord,
+                     unsigned index);
 
-Site*
-pickTargetSite(Context* c, Read* read, bool intersectRead = false,
-               unsigned registerReserveCount = 0,
-               CostCalculator* costCalculator = 0);
+Site* pickTargetSite(Context* c,
+                     Read* read,
+                     bool intersectRead = false,
+                     unsigned registerReserveCount = 0,
+                     CostCalculator* costCalculator = 0);
 Value* threadRegister(Context* c);
 
-Event::Event(Context* c):
-  next(0), stackBefore(c->stack), localsBefore(c->locals),
-  stackAfter(0), localsAfter(0), promises(0), reads(0),
-  junctionSites(0), snapshots(0), predecessors(0), successors(0),
-  visitLinks(0), block(0), logicalInstruction(c->logicalCode[c->logicalIp]),
-  readCount(0)
-{ }
+Event::Event(Context* c)
+    : next(0),
+      stackBefore(c->stack),
+      localsBefore(c->locals),
+      stackAfter(0),
+      localsAfter(0),
+      promises(0),
+      reads(0),
+      junctionSites(0),
+      snapshots(0),
+      predecessors(0),
+      successors(0),
+      visitLinks(0),
+      block(0),
+      logicalInstruction(c->logicalCode[c->logicalIp]),
+      readCount(0)
+{
+}
 
-void Event::addRead(Context* c, Value* v, Read* r) {
+void Event::addRead(Context* c, Value* v, Read* r)
+{
   if (DebugReads) {
-    fprintf(stderr, "add read %p to %p last %p event %p (%s)\n",
-            r, v, v->lastRead, this, (this ? this->name() : 0));
+    fprintf(stderr,
+            "add read %p to %p last %p event %p (%s)\n",
+            r,
+            v,
+            v->lastRead,
+            this,
+            (this ? this->name() : 0));
   }
 
   r->value = v;
@@ -105,7 +144,7 @@ void Event::addRead(Context* c, Value* v, Read* r) {
     r->event = this;
     r->eventNext = this->reads;
     this->reads = r;
-    ++ this->readCount;
+    ++this->readCount;
   }
 
   if (v->lastRead) {
@@ -120,13 +159,21 @@ void Event::addRead(Context* c, Value* v, Read* r) {
   v->lastRead = r;
 }
 
-void Event::addRead(Context* c, Value* v, const SiteMask& mask, Value* successor) {
+void Event::addRead(Context* c,
+                    Value* v,
+                    const SiteMask& mask,
+                    Value* successor)
+{
   this->addRead(c, v, read(c, mask, successor));
 }
 
-void Event::addReads(Context* c, Value* v, unsigned size,
-         const SiteMask& lowMask, Value* lowSuccessor,
-         const SiteMask& highMask, Value* highSuccessor)
+void Event::addReads(Context* c,
+                     Value* v,
+                     unsigned size,
+                     const SiteMask& lowMask,
+                     Value* lowSuccessor,
+                     const SiteMask& highMask,
+                     Value* highSuccessor)
 {
   SingleRead* r = read(c, lowMask, lowSuccessor);
   this->addRead(c, v, r);
@@ -136,33 +183,41 @@ void Event::addReads(Context* c, Value* v, unsigned size,
   }
 }
 
-void Event::addReads(Context* c, Value* v, unsigned size,
-         const SiteMask& lowMask, const SiteMask& highMask)
+void Event::addReads(Context* c,
+                     Value* v,
+                     unsigned size,
+                     const SiteMask& lowMask,
+                     const SiteMask& highMask)
 {
   this->addReads(c, v, size, lowMask, 0, highMask, 0);
 }
 
-CodePromise* Event::makeCodePromise(Context* c) {
-  return this->promises = new(c->zone) CodePromise(c, this->promises);
+CodePromise* Event::makeCodePromise(Context* c)
+{
+  return this->promises = new (c->zone) CodePromise(c, this->promises);
 }
 
-bool Event::isUnreachable() {
+bool Event::isUnreachable()
+{
   for (Link* p = this->predecessors; p; p = p->nextPredecessor) {
-    if (not p->predecessor->allExits()) return false;
+    if (not p->predecessor->allExits())
+      return false;
   }
   return this->predecessors != 0;
 }
 
-unsigned Link::countPredecessors() {
+unsigned Link::countPredecessors()
+{
   Link* link = this;
   unsigned c = 0;
   for (; link; link = link->nextPredecessor) {
-    ++ c;
+    ++c;
   }
   return c;
 }
 
-Link* Link::lastPredecessor() {
+Link* Link::lastPredecessor()
+{
   Link* link = this;
   while (link->nextPredecessor) {
     link = link->nextPredecessor;
@@ -170,20 +225,25 @@ Link* Link::lastPredecessor() {
   return link;
 }
 
-unsigned Link::countSuccessors() {
+unsigned Link::countSuccessors()
+{
   Link* link = this;
   unsigned c = 0;
   for (; link; link = link->nextSuccessor) {
-    ++ c;
+    ++c;
   }
   return c;
 }
 
-Link* link(Context* c, Event* predecessor, Link* nextPredecessor, Event* successor,
-     Link* nextSuccessor, ForkState* forkState)
+Link* link(Context* c,
+           Event* predecessor,
+           Link* nextPredecessor,
+           Event* successor,
+           Link* nextSuccessor,
+           ForkState* forkState)
 {
-  return new(c->zone) Link
-    (predecessor, nextPredecessor, successor, nextSuccessor, forkState);
+  return new (c->zone)
+      Link(predecessor, nextPredecessor, successor, nextSuccessor, forkState);
 }
 
 Value* maybeBuddySlice(Context* c, Value* v)
@@ -290,7 +350,7 @@ void slicePush(Context* c,
   }
 }
 
-class CallEvent: public Event {
+class CallEvent : public Event {
  public:
   CallEvent(Context* c,
             Value* address,
@@ -324,20 +384,18 @@ class CallEvent: public Event {
       while (true) {
         Value* v = static_cast<Value*>(arguments[argumentIndex]);
 
-        unsigned footprint
-            = (argumentIndex + 1 < arguments.count and v->nextWord
-               == arguments[argumentIndex + 1])
-                  ? 2
-                  : 1;
+        unsigned footprint = (argumentIndex + 1 < arguments.count
+                              and v->nextWord == arguments[argumentIndex + 1])
+                                 ? 2
+                                 : 1;
 
         if (index % (c->arch->argumentAlignment() ? footprint : 1)) {
-          ++ index;
+          ++index;
         }
 
         SiteMask targetMask;
         if (index + (c->arch->argumentRegisterAlignment() ? footprint : 1)
-            <= c->arch->argumentRegisterCount())
-        {
+            <= c->arch->argumentRegisterCount()) {
           int number = c->arch->argumentRegister(index);
 
           if (DebugReads) {
@@ -362,7 +420,7 @@ class CallEvent: public Event {
 
         this->addRead(c, v, targetMask);
 
-        ++ index;
+        ++index;
 
         if ((++argumentIndex) >= arguments.count) {
           break;
@@ -374,7 +432,8 @@ class CallEvent: public Event {
       fprintf(stderr, "address read %p\n", address);
     }
 
-    { bool thunk;
+    {
+      bool thunk;
       OperandMask op;
       c->arch->plan((flags & Compiler::Aligned) ? lir::AlignedCall : lir::Call,
                     c->targetInfo.pointerSize,
@@ -383,8 +442,10 @@ class CallEvent: public Event {
 
       assertT(c, not thunk);
 
-      this->addRead(c, address, SiteMask
-               (op.typeMask, registerMask & op.registerMask, AnyFrameIndex));
+      this->addRead(
+          c,
+          address,
+          SiteMask(op.typeMask, registerMask & op.registerMask, AnyFrameIndex));
     }
 
     Stack* stack = stackBefore;
@@ -425,7 +486,7 @@ class CallEvent: public Event {
         }
 
         frameOffset = totalFrameSize(c)
-          - c->arch->argumentFootprint(stackArgumentFootprint);
+                      - c->arch->argumentFootprint(stackArgumentFootprint);
       } else {
         returnAddressIndex = -1;
         framePointerIndex = -1;
@@ -438,8 +499,11 @@ class CallEvent: public Event {
           int frameIndex = i + frameOffset;
 
           if (DebugReads) {
-            fprintf(stderr, "stack arg read %p at %d of %d\n",
-                    v, frameIndex, totalFrameSize(c));
+            fprintf(stderr,
+                    "stack arg read %p at %d of %d\n",
+                    v,
+                    frameIndex,
+                    totalFrameSize(c));
           }
 
           if (static_cast<int>(frameIndex) == returnAddressIndex) {
@@ -449,7 +513,8 @@ class CallEvent: public Event {
             framePointerSurrogate = v;
             this->addRead(c, v, generalRegisterMask(c));
           } else {
-            this->addRead(c, v, SiteMask(1 << lir::MemoryOperand, 0, frameIndex));
+            this->addRead(
+                c, v, SiteMask(1 << lir::MemoryOperand, 0, frameIndex));
           }
         }
       }
@@ -461,26 +526,27 @@ class CallEvent: public Event {
         stackArgumentIndex += stackBefore->index + 1 - stackArgumentFootprint;
       }
 
-      popIndex
-        = c->alignedFrameSize
-        + c->parameterFootprint
-        - c->arch->frameFooterSize()
-        - stackArgumentIndex;
+      popIndex = c->alignedFrameSize + c->parameterFootprint
+                 - c->arch->frameFooterSize() - stackArgumentIndex;
 
       assertT(c, static_cast<int>(popIndex) >= 0);
 
       while (stack) {
         if (stack->value) {
-          unsigned logicalIndex = compiler::frameIndex
-            (c, stack->index + c->localFootprint);
+          unsigned logicalIndex
+              = compiler::frameIndex(c, stack->index + c->localFootprint);
 
           if (DebugReads) {
-            fprintf(stderr, "stack save read %p at %d of %d\n",
-                    stack->value, logicalIndex, totalFrameSize(c));
+            fprintf(stderr,
+                    "stack save read %p at %d of %d\n",
+                    stack->value,
+                    logicalIndex,
+                    totalFrameSize(c));
           }
 
-          this->addRead(c, stack->value, SiteMask
-                  (1 << lir::MemoryOperand, 0, logicalIndex));
+          this->addRead(c,
+                        stack->value,
+                        SiteMask(1 << lir::MemoryOperand, 0, logicalIndex));
         }
 
         stack = stack->next;
@@ -490,11 +556,13 @@ class CallEvent: public Event {
     }
   }
 
-  virtual const char* name() {
+  virtual const char* name()
+  {
     return "CallEvent";
   }
 
-  virtual void compile(Context* c) {
+  virtual void compile(Context* c)
+  {
     lir::UnaryOperation op;
 
     unsigned footprint = c->arch->argumentFootprint(stackArgumentFootprint);
@@ -525,8 +593,8 @@ class CallEvent: public Event {
       if (returnAddressSurrogate) {
         returnAddressSurrogate->source->freeze(c, returnAddressSurrogate);
 
-        ras = static_cast<RegisterSite*>
-          (returnAddressSurrogate->source)->number;
+        ras = static_cast<RegisterSite*>(returnAddressSurrogate->source)
+                  ->number;
       } else {
         ras = lir::NoRegister;
       }
@@ -535,8 +603,7 @@ class CallEvent: public Event {
       if (framePointerSurrogate) {
         framePointerSurrogate->source->freeze(c, framePointerSurrogate);
 
-        fps = static_cast<RegisterSite*>
-          (framePointerSurrogate->source)->number;
+        fps = static_cast<RegisterSite*>(framePointerSurrogate->source)->number;
       } else {
         fps = lir::NoRegister;
       }
@@ -591,7 +658,8 @@ class CallEvent: public Event {
     }
   }
 
-  virtual bool allExits() {
+  virtual bool allExits()
+  {
     return (flags & Compiler::TailJump) != 0;
   }
 
@@ -624,8 +692,7 @@ void appendCall(Context* c,
                                  arguments));
 }
 
-
-class ReturnEvent: public Event {
+class ReturnEvent : public Event {
  public:
   ReturnEvent(Context* c, Value* value) : Event(c), value(value)
   {
@@ -638,19 +705,21 @@ class ReturnEvent: public Event {
     }
   }
 
-  virtual const char* name() {
+  virtual const char* name()
+  {
     return "ReturnEvent";
   }
 
-  virtual void compile(Context* c) {
+  virtual void compile(Context* c)
+  {
     for (Read* r = reads; r; r = r->eventNext) {
       popRead(c, this, r->value);
     }
-    
+
     if (not this->isUnreachable()) {
-      c->assembler->popFrameAndPopArgumentsAndReturn
-        (c->alignedFrameSize,
-         c->arch->argumentFootprint(c->parameterFootprint));
+      c->assembler->popFrameAndPopArgumentsAndReturn(
+          c->alignedFrameSize,
+          c->arch->argumentFootprint(c->parameterFootprint));
     }
   }
 
@@ -662,7 +731,7 @@ void appendReturn(Context* c, Value* value)
   append(c, new (c->zone) ReturnEvent(c, value));
 }
 
-class MoveEvent: public Event {
+class MoveEvent : public Event {
  public:
   MoveEvent(Context* c,
             lir::BinaryOperation op,
@@ -703,11 +772,13 @@ class MoveEvent: public Event {
         noop and dstSize > c->targetInfo.pointerSize ? dstValue->nextWord : 0);
   }
 
-  virtual const char* name() {
+  virtual const char* name()
+  {
     return "MoveEvent";
   }
 
-  virtual void compile(Context* c) {
+  virtual void compile(Context* c)
+  {
     OperandMask dst;
 
     c->arch->planDestination(
@@ -728,9 +799,15 @@ class MoveEvent: public Event {
       if (dstValue->target) {
         if (dstSize > c->targetInfo.pointerSize) {
           if (srcValue->source->registerSize(c) > c->targetInfo.pointerSize) {
-            apply(c, lir::Move, srcSelectSize, srcValue->source, srcValue->source,
-                  dstSize, dstValue->target, dstValue->target);
-            
+            apply(c,
+                  lir::Move,
+                  srcSelectSize,
+                  srcValue->source,
+                  srcValue->source,
+                  dstSize,
+                  dstValue->target,
+                  dstValue->target);
+
             if (live(c, dstValue) == 0) {
               dstValue->removeSite(c, dstValue->target);
               if (dstSize > c->targetInfo.pointerSize) {
@@ -800,12 +877,13 @@ class MoveEvent: public Event {
         dstValue->addSite(c, low);
 
         low->freeze(c, dstValue);
-          
+
         if (DebugMoves) {
-          char srcb[256]; srcValue->source->toString(c, srcb, 256);
-          char dstb[256]; low->toString(c, dstb, 256);
-          fprintf(stderr, "move %s to %s for %p\n",
-                  srcb, dstb, srcValue);
+          char srcb[256];
+          srcValue->source->toString(c, srcb, 256);
+          char dstb[256];
+          low->toString(c, dstb, 256);
+          fprintf(stderr, "move %s to %s for %p\n", srcb, dstb, srcValue);
         }
 
         apply(c,
@@ -830,12 +908,18 @@ class MoveEvent: public Event {
         dstValue->nextWord->addSite(c, high);
 
         high->freeze(c, dstValue->nextWord);
-        
+
         if (DebugMoves) {
-          char srcb[256]; low->toString(c, srcb, 256);
-          char dstb[256]; high->toString(c, dstb, 256);
-          fprintf(stderr, "extend %s to %s for %p %p\n",
-                  srcb, dstb, dstValue, dstValue->nextWord);
+          char srcb[256];
+          low->toString(c, srcb, 256);
+          char dstb[256];
+          high->toString(c, dstb, 256);
+          fprintf(stderr,
+                  "extend %s to %s for %p %p\n",
+                  srcb,
+                  dstb,
+                  dstValue,
+                  dstValue->nextWord);
         }
 
         apply(c,
@@ -895,9 +979,7 @@ void appendMove(Context* c,
                                  SiteMask::highPart(src)));
 }
 
-
-void
-freezeSource(Context* c, unsigned size, Value* v)
+void freezeSource(Context* c, unsigned size, Value* v)
 {
   v->source->freeze(c, v);
   if (size > c->targetInfo.pointerSize) {
@@ -905,8 +987,7 @@ freezeSource(Context* c, unsigned size, Value* v)
   }
 }
 
-void
-thawSource(Context* c, unsigned size, Value* v)
+void thawSource(Context* c, unsigned size, Value* v)
 {
   v->source->thaw(c, v);
   if (size > c->targetInfo.pointerSize) {
@@ -914,20 +995,24 @@ thawSource(Context* c, unsigned size, Value* v)
   }
 }
 
-Read* liveNext(Context* c, Value* v) {
+Read* liveNext(Context* c, Value* v)
+{
   assertT(c, v->buddy->hasBuddy(c, v));
 
   Read* r = v->reads->next(c);
-  if (valid(r)) return r;
+  if (valid(r))
+    return r;
 
   for (Value* p = v->buddy; p != v; p = p->buddy) {
-    if (valid(p->reads)) return p->reads;
+    if (valid(p->reads))
+      return p->reads;
   }
 
   return 0;
 }
 
-void preserve(Context* c, Value* v, Read* r, Site* s) {
+void preserve(Context* c, Value* v, Read* r, Site* s)
+{
   s->freeze(c, v);
 
   maybeMove(c, r, false, true, 0);
@@ -935,15 +1020,18 @@ void preserve(Context* c, Value* v, Read* r, Site* s) {
   s->thaw(c, v);
 }
 
-Site* getTarget(Context* c, Value* value, Value* result, const SiteMask& resultMask) {
+Site* getTarget(Context* c,
+                Value* value,
+                Value* result,
+                const SiteMask& resultMask)
+{
   Site* s;
   Value* v;
   Read* r = liveNext(c, value);
-  if (value->source->match
-      (c, static_cast<const SiteMask&>(resultMask))
-      and (r == 0 or value->source->loneMatch
-           (c, static_cast<const SiteMask&>(resultMask))))
-  {
+  if (value->source->match(c, static_cast<const SiteMask&>(resultMask))
+      and (r == 0
+           or value->source->loneMatch(
+                  c, static_cast<const SiteMask&>(resultMask)))) {
     s = value->source;
     v = value;
     if (r and v->uniqueSite(c, s)) {
@@ -965,7 +1053,7 @@ Site* getTarget(Context* c, Value* value, Value* result, const SiteMask& resultM
   return s;
 }
 
-class CombineEvent: public Event {
+class CombineEvent : public Event {
  public:
   CombineEvent(Context* c,
                lir::TernaryOperation op,
@@ -1003,16 +1091,19 @@ class CombineEvent: public Event {
                    condensed ? resultValue->nextWord : 0);
   }
 
-  virtual const char* name() {
+  virtual const char* name()
+  {
     return "CombineEvent";
   }
 
-  virtual void compile(Context* c) {
+  virtual void compile(Context* c)
+  {
     assertT(
         c,
         firstValue->source->type(c) == firstValue->nextWord->source->type(c));
 
-    // if (secondValue->source->type(c) != secondValue->nextWord->source->type(c)) {
+    // if (secondValue->source->type(c) !=
+    // secondValue->nextWord->source->type(c)) {
     //   fprintf(stderr, "%p %p %d : %p %p %d\n",
     //           secondValue, secondValue->source, secondValue->source->type(c),
     //           secondValue->nextWord, secondValue->nextWord->source,
@@ -1058,10 +1149,10 @@ class CombineEvent: public Event {
                                   resultHighMask)
                       : low);
 
-//     fprintf(stderr, "combine %p:%p and %p:%p into %p:%p\n",
-//             firstValue, firstValue->nextWord,
-//             secondValue, secondValue->nextWord,
-//             resultValue, resultValue->nextWord);
+    //     fprintf(stderr, "combine %p:%p and %p:%p into %p:%p\n",
+    //             firstValue, firstValue->nextWord,
+    //             secondValue, secondValue->nextWord,
+    //             resultValue, resultValue->nextWord);
 
     apply(c,
           op,
@@ -1149,7 +1240,7 @@ void appendCombine(Context* c,
               slice);
 
     if (threadParameter) {
-      ++ stackSize;
+      ++stackSize;
 
       slicePush(c, 1, threadRegister(c), stackBase, slice);
     }
@@ -1175,7 +1266,7 @@ void appendCombine(Context* c,
   }
 }
 
-class TranslateEvent: public Event {
+class TranslateEvent : public Event {
  public:
   TranslateEvent(Context* c,
                  lir::BinaryOperation op,
@@ -1200,11 +1291,13 @@ class TranslateEvent: public Event {
                    condensed ? resultValue->nextWord : 0);
   }
 
-  virtual const char* name() {
+  virtual const char* name()
+  {
     return "TranslateEvent";
   }
 
-  virtual void compile(Context* c) {
+  virtual void compile(Context* c)
+  {
     assertT(
         c,
         firstValue->source->type(c) == firstValue->nextWord->source->type(c));
@@ -1225,7 +1318,7 @@ class TranslateEvent: public Event {
 
     SiteMask resultLowMask = SiteMask::lowPart(bMask);
     SiteMask resultHighMask = SiteMask::highPart(bMask);
-    
+
     Site* low = getTarget(c, firstValue, resultValue, resultLowMask);
     unsigned lowSize = low->registerSize(c);
     Site* high = (resultValue->type.size(c->targetInfo) > lowSize
@@ -1326,30 +1419,32 @@ void appendTranslate(Context* c,
   }
 }
 
-class OperationEvent: public Event {
+class OperationEvent : public Event {
  public:
-  OperationEvent(Context* c, lir::Operation op):
-    Event(c), op(op)
-  { }
+  OperationEvent(Context* c, lir::Operation op) : Event(c), op(op)
+  {
+  }
 
-  virtual const char* name() {
+  virtual const char* name()
+  {
     return "OperationEvent";
   }
 
-  virtual void compile(Context* c) {
+  virtual void compile(Context* c)
+  {
     c->assembler->apply(op);
   }
 
   lir::Operation op;
 };
 
-void
-appendOperation(Context* c, lir::Operation op)
+void appendOperation(Context* c, lir::Operation op)
 {
-  append(c, new(c->zone) OperationEvent(c, op));
+  append(c, new (c->zone) OperationEvent(c, op));
 }
 
-ConstantSite* findConstantSite(Context* c, Value* v) {
+ConstantSite* findConstantSite(Context* c, Value* v)
+{
   for (SiteIterator it(c, v); it.hasMore();) {
     Site* s = it.next();
     if (s->type(c) == lir::ConstantOperand) {
@@ -1359,8 +1454,7 @@ ConstantSite* findConstantSite(Context* c, Value* v) {
   return 0;
 }
 
-void
-moveIfConflict(Context* c, Value* v, MemorySite* s)
+void moveIfConflict(Context* c, Value* v, MemorySite* s)
 {
   if (v->reads) {
     SiteMask mask(1 << lir::RegisterOperand, ~0, AnyFrameIndex);
@@ -1372,12 +1466,20 @@ moveIfConflict(Context* c, Value* v, MemorySite* s)
   }
 }
 
-class MemoryEvent: public Event {
+class MemoryEvent : public Event {
  public:
-  MemoryEvent(Context* c, Value* base, int displacement, Value* index,
-              unsigned scale, Value* result):
-    Event(c), base(base), displacement(displacement), index(index),
-    scale(scale), result(result)
+  MemoryEvent(Context* c,
+              Value* base,
+              int displacement,
+              Value* index,
+              unsigned scale,
+              Value* result)
+      : Event(c),
+        base(base),
+        displacement(displacement),
+        index(index),
+        scale(scale),
+        result(result)
   {
     this->addRead(c, base, generalRegisterMask(c));
     if (index) {
@@ -1385,11 +1487,13 @@ class MemoryEvent: public Event {
     }
   }
 
-  virtual const char* name() {
+  virtual const char* name()
+  {
     return "MemoryEvent";
   }
 
-  virtual void compile(Context* c) {
+  virtual void compile(Context* c)
+  {
     int indexRegister;
     int displacement = this->displacement;
     unsigned scale = this->scale;
@@ -1413,15 +1517,21 @@ class MemoryEvent: public Event {
     popRead(c, this, base);
     if (index) {
       if (c->targetInfo.pointerSize == 8 and indexRegister != lir::NoRegister) {
-        apply(c, lir::Move, 4, index->source, index->source,
-              8, index->source, index->source);
+        apply(c,
+              lir::Move,
+              4,
+              index->source,
+              index->source,
+              8,
+              index->source,
+              index->source);
       }
 
       popRead(c, this, index);
     }
 
-    MemorySite* site = memorySite
-      (c, baseRegister, displacement, indexRegister, scale);
+    MemorySite* site
+        = memorySite(c, baseRegister, displacement, indexRegister, scale);
 
     MemorySite* low;
     if (result->nextWord != result) {
@@ -1447,15 +1557,20 @@ class MemoryEvent: public Event {
   Value* result;
 };
 
-void
-appendMemory(Context* c, Value* base, int displacement, Value* index,
-             unsigned scale, Value* result)
+void appendMemory(Context* c,
+                  Value* base,
+                  int displacement,
+                  Value* index,
+                  unsigned scale,
+                  Value* result)
 {
-  append(c, new(c->zone)
+  append(c,
+         new (c->zone)
          MemoryEvent(c, base, displacement, index, scale, result));
 }
 
-double asFloat(unsigned size, int64_t v) {
+double asFloat(unsigned size, int64_t v)
+{
   if (size == 4) {
     return vm::bitsToFloat(v);
   } else {
@@ -1463,10 +1578,9 @@ double asFloat(unsigned size, int64_t v) {
   }
 }
 
-bool
-unordered(double a, double b)
+bool unordered(double a, double b)
 {
-  return not (a >= b or a < b);
+  return not(a >= b or a < b);
 }
 
 bool shouldJump(Context* c,
@@ -1514,19 +1628,19 @@ bool shouldJump(Context* c,
 
   case lir::JumpIfFloatLessOrUnordered:
     return asFloat(size, a) < asFloat(size, b)
-      or unordered(asFloat(size, a), asFloat(size, b));
+           or unordered(asFloat(size, a), asFloat(size, b));
 
   case lir::JumpIfFloatGreaterOrUnordered:
     return asFloat(size, a) > asFloat(size, b)
-      or unordered(asFloat(size, a), asFloat(size, b));
+           or unordered(asFloat(size, a), asFloat(size, b));
 
   case lir::JumpIfFloatLessOrEqualOrUnordered:
     return asFloat(size, a) <= asFloat(size, b)
-      or unordered(asFloat(size, a), asFloat(size, b));
+           or unordered(asFloat(size, a), asFloat(size, b));
 
   case lir::JumpIfFloatGreaterOrEqualOrUnordered:
     return asFloat(size, a) >= asFloat(size, b)
-      or unordered(asFloat(size, a), asFloat(size, b));
+           or unordered(asFloat(size, a), asFloat(size, b));
 
   default:
     abort(c);
@@ -1563,7 +1677,7 @@ lir::TernaryOperation thunkBranch(Context* c, lir::TernaryOperation op)
   }
 }
 
-class BranchEvent: public Event {
+class BranchEvent : public Event {
  public:
   BranchEvent(Context* c,
               lir::TernaryOperation op,
@@ -1603,28 +1717,29 @@ class BranchEvent: public Event {
     this->addRead(c, addressValue, SiteMask::lowPart(dstMask));
   }
 
-  virtual const char* name() {
+  virtual const char* name()
+  {
     return "BranchEvent";
   }
 
-  virtual void compile(Context* c) {
+  virtual void compile(Context* c)
+  {
     ConstantSite* firstConstant = findConstantSite(c, firstValue);
     ConstantSite* secondConstant = findConstantSite(c, secondValue);
 
     if (not this->isUnreachable()) {
-      if (firstConstant
-          and secondConstant
-          and firstConstant->value->resolved()
-          and secondConstant->value->resolved())
-      {
+      if (firstConstant and secondConstant and firstConstant->value->resolved()
+          and secondConstant->value->resolved()) {
         int64_t firstConstVal = firstConstant->value->value();
         int64_t secondConstVal = secondConstant->value->value();
 
         if (firstValue->type.size(c->targetInfo) > c->targetInfo.pointerSize) {
-          firstConstVal |= findConstantSite
-            (c, firstValue->nextWord)->value->value() << 32;
-          secondConstVal |= findConstantSite
-            (c, secondValue->nextWord)->value->value() << 32;
+          firstConstVal
+              |= findConstantSite(c, firstValue->nextWord)->value->value()
+                 << 32;
+          secondConstVal
+              |= findConstantSite(c, secondValue->nextWord)->value->value()
+                 << 32;
         }
 
         if (shouldJump(c,
@@ -1637,7 +1752,7 @@ class BranchEvent: public Event {
                 c->targetInfo.pointerSize,
                 addressValue->source,
                 addressValue->source);
-        }      
+        }
       } else {
         freezeSource(c, firstValue->type.size(c->targetInfo), firstValue);
         freezeSource(c, firstValue->type.size(c->targetInfo), secondValue);
@@ -1666,7 +1781,10 @@ class BranchEvent: public Event {
     }
   }
 
-  virtual bool isBranch() { return true; }
+  virtual bool isBranch()
+  {
+    return true;
+  }
 
   lir::TernaryOperation op;
   Value* firstValue;
@@ -1747,21 +1865,23 @@ void appendBranch(Context* c,
   }
 }
 
-void clean(Context* c, Value* v, unsigned popIndex) {
+void clean(Context* c, Value* v, unsigned popIndex)
+{
   for (SiteIterator it(c, v); it.hasMore();) {
     Site* s = it.next();
-    if (not (s->match(c, SiteMask(1 << lir::MemoryOperand, 0, AnyFrameIndex))
-             and offsetToFrameIndex
-             (c, static_cast<MemorySite*>(s)->offset)
-             >= popIndex))
-    {
-      if (false and
-          s->match(c, SiteMask(1 << lir::MemoryOperand, 0, AnyFrameIndex)))
-      {
-        char buffer[256]; s->toString(c, buffer, 256);
-        fprintf(stderr, "remove %s from %p at %d pop offset 0x%x\n",
-                buffer, v, offsetToFrameIndex
-                (c, static_cast<MemorySite*>(s)->offset),
+    if (not(s->match(c, SiteMask(1 << lir::MemoryOperand, 0, AnyFrameIndex))
+            and offsetToFrameIndex(c, static_cast<MemorySite*>(s)->offset)
+                >= popIndex)) {
+      if (false
+          and s->match(c,
+                       SiteMask(1 << lir::MemoryOperand, 0, AnyFrameIndex))) {
+        char buffer[256];
+        s->toString(c, buffer, 256);
+        fprintf(stderr,
+                "remove %s from %p at %d pop offset 0x%x\n",
+                buffer,
+                v,
+                offsetToFrameIndex(c, static_cast<MemorySite*>(s)->offset),
                 frameIndexToOffset(c, popIndex));
       }
       it.remove(c);
@@ -1769,9 +1889,12 @@ void clean(Context* c, Value* v, unsigned popIndex) {
   }
 }
 
-void
-clean(Context* c, Event* e, Stack* stack, Local* locals, Read* reads,
-      unsigned popIndex)
+void clean(Context* c,
+           Event* e,
+           Stack* stack,
+           Local* locals,
+           Read* reads,
+           unsigned popIndex)
 {
   for (FrameIterator it(c, stack, locals); it.hasMore();) {
     FrameIterator::Element e = it.next(c);
@@ -1783,7 +1906,7 @@ clean(Context* c, Event* e, Stack* stack, Local* locals, Read* reads,
   }
 }
 
-class JumpEvent: public Event {
+class JumpEvent : public Event {
  public:
   JumpEvent(Context* c,
             lir::UnaryOperation op,
@@ -1801,11 +1924,13 @@ class JumpEvent: public Event {
     this->addRead(c, address, SiteMask::lowPart(mask));
   }
 
-  virtual const char* name() {
+  virtual const char* name()
+  {
     return "JumpEvent";
   }
 
-  virtual void compile(Context* c) {
+  virtual void compile(Context* c)
+  {
     if (not this->isUnreachable()) {
       apply(c, op, c->targetInfo.pointerSize, address->source, address->source);
     }
@@ -1822,9 +1947,13 @@ class JumpEvent: public Event {
     }
   }
 
-  virtual bool isBranch() { return true; }
+  virtual bool isBranch()
+  {
+    return true;
+  }
 
-  virtual bool allExits() {
+  virtual bool allExits()
+  {
     return exit or this->isUnreachable();
   }
 
@@ -1843,22 +1972,30 @@ void appendJump(Context* c,
   append(c, new (c->zone) JumpEvent(c, op, address, exit, cleanLocals));
 }
 
-class BoundsCheckEvent: public Event {
+class BoundsCheckEvent : public Event {
  public:
-  BoundsCheckEvent(Context* c, Value* object, unsigned lengthOffset,
-                   Value* index, intptr_t handler):
-    Event(c), object(object), lengthOffset(lengthOffset), index(index),
-    handler(handler)
+  BoundsCheckEvent(Context* c,
+                   Value* object,
+                   unsigned lengthOffset,
+                   Value* index,
+                   intptr_t handler)
+      : Event(c),
+        object(object),
+        lengthOffset(lengthOffset),
+        index(index),
+        handler(handler)
   {
     this->addRead(c, object, generalRegisterMask(c));
     this->addRead(c, index, generalRegisterOrConstantMask(c));
   }
 
-  virtual const char* name() {
+  virtual const char* name()
+  {
     return "BoundsCheckEvent";
   }
 
-  virtual void compile(Context* c) {
+  virtual void compile(Context* c)
+  {
     Assembler* a = c->assembler;
 
     ConstantSite* constant = findConstantSite(c, index);
@@ -1893,10 +2030,13 @@ class BoundsCheckEvent: public Event {
     if (constant == 0 or constant->value->value() >= 0) {
       assertT(c, object->source->type(c) == lir::RegisterOperand);
       MemorySite length(static_cast<RegisterSite*>(object->source)->number,
-                        lengthOffset, lir::NoRegister, 1);
+                        lengthOffset,
+                        lir::NoRegister,
+                        1);
       length.acquired = true;
 
-      CodePromise* nextPromise = compiler::codePromise(c, static_cast<Promise*>(0));
+      CodePromise* nextPromise
+          = compiler::codePromise(c, static_cast<Promise*>(0));
 
       freezeSource(c, c->targetInfo.pointerSize, index);
 
@@ -1938,25 +2078,31 @@ class BoundsCheckEvent: public Event {
   intptr_t handler;
 };
 
-void
-appendBoundsCheck(Context* c, Value* object, unsigned lengthOffset,
-                  Value* index, intptr_t handler)
+void appendBoundsCheck(Context* c,
+                       Value* object,
+                       unsigned lengthOffset,
+                       Value* index,
+                       intptr_t handler)
 {
-  append(c, new(c->zone) BoundsCheckEvent(c, object, lengthOffset, index, handler));
+  append(c,
+         new (c->zone)
+         BoundsCheckEvent(c, object, lengthOffset, index, handler));
 }
 
-
-class FrameSiteEvent: public Event {
+class FrameSiteEvent : public Event {
  public:
-  FrameSiteEvent(Context* c, Value* value, int index):
-    Event(c), value(value), index(index)
-  { }
+  FrameSiteEvent(Context* c, Value* value, int index)
+      : Event(c), value(value), index(index)
+  {
+  }
 
-  virtual const char* name() {
+  virtual const char* name()
+  {
     return "FrameSiteEvent";
   }
 
-  virtual void compile(Context* c) {
+  virtual void compile(Context* c)
+  {
     if (live(c, value)) {
       value->addSite(c, frameSite(c, index));
     }
@@ -1966,59 +2112,60 @@ class FrameSiteEvent: public Event {
   int index;
 };
 
-void
-appendFrameSite(Context* c, Value* value, int index)
+void appendFrameSite(Context* c, Value* value, int index)
 {
-  append(c, new(c->zone) FrameSiteEvent(c, value, index));
+  append(c, new (c->zone) FrameSiteEvent(c, value, index));
 }
 
-class SaveLocalsEvent: public Event {
+class SaveLocalsEvent : public Event {
  public:
-  SaveLocalsEvent(Context* c):
-    Event(c)
+  SaveLocalsEvent(Context* c) : Event(c)
   {
     saveLocals(c, this);
   }
 
-  virtual const char* name() {
+  virtual const char* name()
+  {
     return "SaveLocalsEvent";
   }
 
-  virtual void compile(Context* c) {
+  virtual void compile(Context* c)
+  {
     for (Read* r = reads; r; r = r->eventNext) {
       popRead(c, this, r->value);
     }
   }
 };
 
-void
-appendSaveLocals(Context* c)
+void appendSaveLocals(Context* c)
 {
-  append(c, new(c->zone) SaveLocalsEvent(c));
+  append(c, new (c->zone) SaveLocalsEvent(c));
 }
 
-class DummyEvent: public Event {
+class DummyEvent : public Event {
  public:
-  DummyEvent(Context* c, Local* locals):
-  Event(c),
-  locals_(locals)
-  { }
+  DummyEvent(Context* c, Local* locals) : Event(c), locals_(locals)
+  {
+  }
 
-  virtual const char* name() {
+  virtual const char* name()
+  {
     return "DummyEvent";
   }
 
-  virtual void compile(Context*) { }
+  virtual void compile(Context*)
+  {
+  }
 
-  virtual Local* locals() {
+  virtual Local* locals()
+  {
     return locals_;
   }
 
   Local* locals_;
 };
 
-void
-appendDummy(Context* c)
+void appendDummy(Context* c)
 {
   Stack* stack = c->stack;
   Local* locals = c->locals;
@@ -2027,12 +2174,12 @@ appendDummy(Context* c)
   c->stack = i->stack;
   c->locals = i->locals;
 
-  append(c, new(c->zone) DummyEvent(c, locals));
+  append(c, new (c->zone) DummyEvent(c, locals));
 
   c->stack = stack;
-  c->locals = locals;  
+  c->locals = locals;
 }
 
-} // namespace compiler
-} // namespace codegen
-} // namespace avian
+}  // namespace compiler
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/compiler/event.h b/src/codegen/compiler/event.h
index 03e21d2bc2..dbdb896edb 100644
--- a/src/codegen/compiler/event.h
+++ b/src/codegen/compiler/event.h
@@ -33,25 +33,41 @@ class Event {
 
   virtual void compile(Context* c) = 0;
 
-  virtual bool isBranch() { return false; }
-
-  virtual bool allExits() { return false; }
-
-  virtual Local* locals() { return localsBefore; }
+  virtual bool isBranch()
+  {
+    return false;
+  }
 
+  virtual bool allExits()
+  {
+    return false;
+  }
 
+  virtual Local* locals()
+  {
+    return localsBefore;
+  }
 
   void addRead(Context* c, Value* v, Read* r);
 
-  void addRead(Context* c, Value* v, const SiteMask& mask,
-          Value* successor = 0);
+  void addRead(Context* c,
+               Value* v,
+               const SiteMask& mask,
+               Value* successor = 0);
 
-  void addReads(Context* c, Value* v, unsigned size,
-           const SiteMask& lowMask, Value* lowSuccessor,
-           const SiteMask& highMask, Value* highSuccessor);
+  void addReads(Context* c,
+                Value* v,
+                unsigned size,
+                const SiteMask& lowMask,
+                Value* lowSuccessor,
+                const SiteMask& highMask,
+                Value* highSuccessor);
 
-  void addReads(Context* c, Value* v, unsigned size,
-           const SiteMask& lowMask, const SiteMask& highMask);
+  void addReads(Context* c,
+                Value* v,
+                unsigned size,
+                const SiteMask& lowMask,
+                const SiteMask& highMask);
 
   CodePromise* makeCodePromise(Context* c);
 
@@ -82,7 +98,9 @@ class StubReadPair {
 
 class JunctionState {
  public:
-  JunctionState(unsigned frameFootprint): frameFootprint(frameFootprint) { }
+  JunctionState(unsigned frameFootprint) : frameFootprint(frameFootprint)
+  {
+  }
 
   unsigned frameFootprint;
   StubReadPair reads[0];
@@ -90,12 +108,19 @@ class JunctionState {
 
 class Link {
  public:
-  Link(Event* predecessor, Link* nextPredecessor, Event* successor,
-       Link* nextSuccessor, ForkState* forkState):
-    predecessor(predecessor), nextPredecessor(nextPredecessor),
-    successor(successor), nextSuccessor(nextSuccessor), forkState(forkState),
-    junctionState(0)
-  { }
+  Link(Event* predecessor,
+       Link* nextPredecessor,
+       Event* successor,
+       Link* nextSuccessor,
+       ForkState* forkState)
+      : predecessor(predecessor),
+        nextPredecessor(nextPredecessor),
+        successor(successor),
+        nextSuccessor(nextSuccessor),
+        forkState(forkState),
+        junctionState(0)
+  {
+  }
 
   unsigned countPredecessors();
   Link* lastPredecessor();
@@ -109,9 +134,12 @@ class Link {
   JunctionState* junctionState;
 };
 
-Link*
-link(Context* c, Event* predecessor, Link* nextPredecessor, Event* successor,
-     Link* nextSuccessor, ForkState* forkState);
+Link* link(Context* c,
+           Event* predecessor,
+           Link* nextPredecessor,
+           Event* successor,
+           Link* nextSuccessor,
+           ForkState* forkState);
 
 void appendCall(Context* c,
                 Value* address,
@@ -142,12 +170,14 @@ void appendTranslate(Context* c,
                      Value* first,
                      Value* result);
 
-void
-appendOperation(Context* c, lir::Operation op);
+void appendOperation(Context* c, lir::Operation op);
 
-void
-appendMemory(Context* c, Value* base, int displacement, Value* index,
-             unsigned scale, Value* result);
+void appendMemory(Context* c,
+                  Value* base,
+                  int displacement,
+                  Value* index,
+                  unsigned scale,
+                  Value* result);
 
 void appendBranch(Context* c,
                   lir::TernaryOperation op,
@@ -161,23 +191,22 @@ void appendJump(Context* c,
                 bool exit = false,
                 bool cleanLocals = false);
 
-void
-appendBoundsCheck(Context* c, Value* object, unsigned lengthOffset,
-                  Value* index, intptr_t handler);
+void appendBoundsCheck(Context* c,
+                       Value* object,
+                       unsigned lengthOffset,
+                       Value* index,
+                       intptr_t handler);
 
-void
-appendFrameSite(Context* c, Value* value, int index);
+void appendFrameSite(Context* c, Value* value, int index);
 
-void
-appendSaveLocals(Context* c);
+void appendSaveLocals(Context* c);
 
-void
-appendDummy(Context* c);
+void appendDummy(Context* c);
 
 void appendBuddy(Context* c, Value* original, Value* buddy);
 
-} // namespace compiler
-} // namespace codegen
-} // namespace avian
+}  // namespace compiler
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_COMPILER_EVENT_H
+#endif  // AVIAN_CODEGEN_COMPILER_EVENT_H
diff --git a/src/codegen/compiler/frame.cpp b/src/codegen/compiler/frame.cpp
index c350dc13b9..389c0b06f3 100644
--- a/src/codegen/compiler/frame.cpp
+++ b/src/codegen/compiler/frame.cpp
@@ -19,13 +19,14 @@ namespace avian {
 namespace codegen {
 namespace compiler {
 
-unsigned totalFrameSize(Context* c) {
-  return c->alignedFrameSize
-    + c->arch->frameHeaderSize()
-    + c->arch->argumentFootprint(c->parameterFootprint);
+unsigned totalFrameSize(Context* c)
+{
+  return c->alignedFrameSize + c->arch->frameHeaderSize()
+         + c->arch->argumentFootprint(c->parameterFootprint);
 }
 
-int frameIndex(Context* c, int localIndex) {
+int frameIndex(Context* c, int localIndex)
+{
   assertT(c, localIndex >= 0);
 
   int index = c->alignedFrameSize + c->parameterFootprint - localIndex - 1;
@@ -42,13 +43,15 @@ int frameIndex(Context* c, int localIndex) {
   return index;
 }
 
-unsigned frameIndexToOffset(Context* c, unsigned frameIndex) {
+unsigned frameIndexToOffset(Context* c, unsigned frameIndex)
+{
   assertT(c, frameIndex < totalFrameSize(c));
 
   return (frameIndex + c->arch->frameFooterSize()) * c->targetInfo.pointerSize;
 }
 
-unsigned offsetToFrameIndex(Context* c, unsigned offset) {
+unsigned offsetToFrameIndex(Context* c, unsigned offset)
+{
   assertT(c,
           static_cast<int>((offset / c->targetInfo.pointerSize)
                            - c->arch->frameFooterSize()) >= 0);
@@ -59,43 +62,50 @@ unsigned offsetToFrameIndex(Context* c, unsigned offset) {
   return (offset / c->targetInfo.pointerSize) - c->arch->frameFooterSize();
 }
 
-unsigned frameBase(Context* c) {
-  return c->alignedFrameSize
-    - c->arch->frameReturnAddressSize()
-    - c->arch->frameFooterSize()
-    + c->arch->frameHeaderSize();
-} 
+unsigned frameBase(Context* c)
+{
+  return c->alignedFrameSize - c->arch->frameReturnAddressSize()
+         - c->arch->frameFooterSize() + c->arch->frameHeaderSize();
+}
 
-FrameIterator::Element::Element(Value* value, unsigned localIndex):
-  value(value), localIndex(localIndex)
-{ }
+FrameIterator::Element::Element(Value* value, unsigned localIndex)
+    : value(value), localIndex(localIndex)
+{
+}
 
-
-int FrameIterator::Element::frameIndex(Context* c) {
+int FrameIterator::Element::frameIndex(Context* c)
+{
   return compiler::frameIndex(c, this->localIndex);
 }
 
-FrameIterator::FrameIterator(Context* c, Stack* stack, Local* locals,
-              bool includeEmpty):
-  stack(stack), locals(locals), localIndex(c->localFootprint - 1),
-  includeEmpty(includeEmpty)
-{ }
+FrameIterator::FrameIterator(Context* c,
+                             Stack* stack,
+                             Local* locals,
+                             bool includeEmpty)
+    : stack(stack),
+      locals(locals),
+      localIndex(c->localFootprint - 1),
+      includeEmpty(includeEmpty)
+{
+}
 
-bool FrameIterator::hasMore() {
+bool FrameIterator::hasMore()
+{
   if (not includeEmpty) {
     while (stack and stack->value == 0) {
       stack = stack->next;
     }
 
     while (localIndex >= 0 and locals[localIndex].value == 0) {
-      -- localIndex;
+      --localIndex;
     }
   }
 
   return stack != 0 or localIndex >= 0;
 }
 
-FrameIterator::Element FrameIterator::next(Context* c) {
+FrameIterator::Element FrameIterator::next(Context* c)
+{
   Value* v;
   unsigned li;
   if (stack) {
@@ -107,17 +117,16 @@ FrameIterator::Element FrameIterator::next(Context* c) {
     Local* l = locals + localIndex;
     v = l->value;
     li = localIndex;
-    -- localIndex;
+    --localIndex;
   }
   return Element(v, li);
 }
 
-Stack* stack(Context* c, Value* value, Stack* next) {
-  return new(c->zone) Stack(next ? next->index + 1 : 0, value, next);
+Stack* stack(Context* c, Value* value, Stack* next)
+{
+  return new (c->zone) Stack(next ? next->index + 1 : 0, value, next);
 }
 
-
-
-} // namespace compiler
-} // namespace codegen
-} // namespace avian
+}  // namespace compiler
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/compiler/frame.h b/src/codegen/compiler/frame.h
index de361765fe..e0cf976d0b 100644
--- a/src/codegen/compiler/frame.h
+++ b/src/codegen/compiler/frame.h
@@ -37,7 +37,9 @@ class FrameIterator {
     const unsigned localIndex;
   };
 
-  FrameIterator(Context* c, Stack* stack, Local* locals,
+  FrameIterator(Context* c,
+                Stack* stack,
+                Local* locals,
                 bool includeEmpty = false);
 
   bool hasMore();
@@ -57,9 +59,10 @@ class Local {
 
 class Stack {
  public:
-  Stack(unsigned index, Value* value, Stack* next):
-    index(index), value(value), next(next)
-  { }
+  Stack(unsigned index, Value* value, Stack* next)
+      : index(index), value(value), next(next)
+  {
+  }
 
   unsigned index;
   Value* value;
@@ -68,8 +71,8 @@ class Stack {
 
 Stack* stack(Context* c, Value* value, Stack* next);
 
-} // namespace compiler
-} // namespace codegen
-} // namespace avian
+}  // namespace compiler
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_COMPILER_FRAME_H
+#endif  // AVIAN_CODEGEN_COMPILER_FRAME_H
diff --git a/src/codegen/compiler/ir.cpp b/src/codegen/compiler/ir.cpp
index abd6cc608f..aa9534adda 100644
--- a/src/codegen/compiler/ir.cpp
+++ b/src/codegen/compiler/ir.cpp
@@ -23,31 +23,35 @@ LogicalInstruction::LogicalInstruction(int index, Stack* stack, Local* locals)
       locals(locals),
       machineOffset(0),
       /*subroutine(0), */ index(index)
-{ }
+{
+}
 
-LogicalInstruction* LogicalInstruction::next(Context* c) {
+LogicalInstruction* LogicalInstruction::next(Context* c)
+{
   LogicalInstruction* i = this;
   for (size_t n = i->index + 1; n < c->logicalCode.count(); ++n) {
     i = c->logicalCode[n];
-    if (i) return i;
+    if (i)
+      return i;
   }
   return 0;
 }
 
-unsigned
-machineOffset(Context* c, int logicalIp)
+unsigned machineOffset(Context* c, int logicalIp)
 {
   return c->logicalCode[logicalIp]->machineOffset->value();
 }
 
-Block::Block(Event* head):
-  head(head), nextBlock(0), nextInstruction(0), assemblerBlock(0), start(0)
-{ }
-
-Block* block(Context* c, Event* head) {
-  return new(c->zone) Block(head);
+Block::Block(Event* head)
+    : head(head), nextBlock(0), nextInstruction(0), assemblerBlock(0), start(0)
+{
 }
 
-} // namespace compiler
-} // namespace codegen
-} // namespace avian
+Block* block(Context* c, Event* head)
+{
+  return new (c->zone) Block(head);
+}
+
+}  // namespace compiler
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/compiler/ir.h b/src/codegen/compiler/ir.h
index 8b919c44a4..64e34bfc4e 100644
--- a/src/codegen/compiler/ir.h
+++ b/src/codegen/compiler/ir.h
@@ -24,17 +24,21 @@ class ForkElement {
   bool local;
 };
 
-class ForkState: public Compiler::State {
+class ForkState : public Compiler::State {
  public:
-  ForkState(Stack* stack, Local* locals, List<Value*>* saved, Event* predecessor,
-            unsigned logicalIp):
-    stack(stack),
-    locals(locals),
-    saved(saved),
-    predecessor(predecessor),
-    logicalIp(logicalIp),
-    readCount(0)
-  { }
+  ForkState(Stack* stack,
+            Local* locals,
+            List<Value*>* saved,
+            Event* predecessor,
+            unsigned logicalIp)
+      : stack(stack),
+        locals(locals),
+        saved(saved),
+        predecessor(predecessor),
+        logicalIp(logicalIp),
+        readCount(0)
+  {
+  }
 
   Stack* stack;
   Local* locals;
@@ -75,8 +79,8 @@ Block* block(Context* c, Event* head);
 
 unsigned machineOffset(Context* c, int logicalIp);
 
-} // namespace compiler
-} // namespace codegen
-} // namespace avian
+}  // namespace compiler
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_COMPILER_IR_H
+#endif  // AVIAN_CODEGEN_COMPILER_IR_H
diff --git a/src/codegen/compiler/promise.cpp b/src/codegen/compiler/promise.cpp
index 1567140cca..ef370be200 100644
--- a/src/codegen/compiler/promise.cpp
+++ b/src/codegen/compiler/promise.cpp
@@ -18,88 +18,104 @@ namespace avian {
 namespace codegen {
 namespace compiler {
 
-CodePromise::CodePromise(Context* c, CodePromise* next):
-  c(c), offset(0), next(next)
-{ }
+CodePromise::CodePromise(Context* c, CodePromise* next)
+    : c(c), offset(0), next(next)
+{
+}
 
-CodePromise::CodePromise(Context* c, Promise* offset):
-  c(c), offset(offset), next(0)
-{ }
+CodePromise::CodePromise(Context* c, Promise* offset)
+    : c(c), offset(offset), next(0)
+{
+}
 
-int64_t CodePromise::value() {
+int64_t CodePromise::value()
+{
   if (resolved()) {
     return reinterpret_cast<intptr_t>(c->machineCode + offset->value());
   }
-  
+
   abort(c);
 }
 
-bool CodePromise::resolved() {
+bool CodePromise::resolved()
+{
   return c->machineCode != 0 and offset and offset->resolved();
 }
 
-CodePromise* codePromise(Context* c, Promise* offset) {
+CodePromise* codePromise(Context* c, Promise* offset)
+{
   return new (c->zone) CodePromise(c, offset);
 }
 
-Promise* shiftMaskPromise(Context* c, Promise* base, unsigned shift, int64_t mask) {
+Promise* shiftMaskPromise(Context* c,
+                          Promise* base,
+                          unsigned shift,
+                          int64_t mask)
+{
   return new (c->zone) ShiftMaskPromise(base, shift, mask);
 }
 
-Promise* combinedPromise(Context* c, Promise* low, Promise* high) {
+Promise* combinedPromise(Context* c, Promise* low, Promise* high)
+{
   return new (c->zone) CombinedPromise(low, high);
 }
 
-Promise* resolvedPromise(Context* c, int64_t value) {
+Promise* resolvedPromise(Context* c, int64_t value)
+{
   return new (c->zone) ResolvedPromise(value);
 }
 
-class IpPromise: public Promise {
+class IpPromise : public Promise {
  public:
-  IpPromise(Context* c, int logicalIp):
-    c(c),
-    logicalIp(logicalIp)
-  { }
+  IpPromise(Context* c, int logicalIp) : c(c), logicalIp(logicalIp)
+  {
+  }
 
-  virtual int64_t value() {
+  virtual int64_t value()
+  {
     if (resolved()) {
-      return reinterpret_cast<intptr_t>
-        (c->machineCode + machineOffset(c, logicalIp));
+      return reinterpret_cast<intptr_t>(c->machineCode
+                                        + machineOffset(c, logicalIp));
     }
 
     abort(c);
   }
 
-  virtual bool resolved() {
+  virtual bool resolved()
+  {
     return c->machineCode != 0
-      and c->logicalCode[logicalIp]->machineOffset->resolved();
+           and c->logicalCode[logicalIp]->machineOffset->resolved();
   }
 
   Context* c;
   int logicalIp;
 };
 
-Promise* ipPromise(Context* c, int logicalIp) {
+Promise* ipPromise(Context* c, int logicalIp)
+{
   return new (c->zone) IpPromise(c, logicalIp);
 }
 
-
-class PoolPromise: public Promise {
+class PoolPromise : public Promise {
  public:
-  PoolPromise(Context* c, int key): c(c), key(key) { }
+  PoolPromise(Context* c, int key) : c(c), key(key)
+  {
+  }
 
-  virtual int64_t value() {
+  virtual int64_t value()
+  {
     if (resolved()) {
       return reinterpret_cast<int64_t>(
           c->machineCode
           + vm::pad(c->machineCodeSize, c->targetInfo.pointerSize)
           + (key * c->targetInfo.pointerSize));
     }
-    
+
     abort(c);
   }
 
-  virtual bool resolved() {
+  virtual bool resolved()
+  {
     return c->machineCode != 0;
   }
 
@@ -107,11 +123,11 @@ class PoolPromise: public Promise {
   int key;
 };
 
-Promise* poolPromise(Context* c, int key) {
-  return new(c->zone) PoolPromise(c, key);
+Promise* poolPromise(Context* c, int key)
+{
+  return new (c->zone) PoolPromise(c, key);
 }
 
-
-} // namespace compiler
-} // namespace codegen
-} // namespace avian
+}  // namespace compiler
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/compiler/promise.h b/src/codegen/compiler/promise.h
index e575df3185..d8a74be27b 100644
--- a/src/codegen/compiler/promise.h
+++ b/src/codegen/compiler/promise.h
@@ -15,8 +15,7 @@ namespace avian {
 namespace codegen {
 namespace compiler {
 
-
-class CodePromise: public Promise {
+class CodePromise : public Promise {
  public:
   CodePromise(Context* c, CodePromise* next);
 
@@ -33,7 +32,10 @@ class CodePromise: public Promise {
 
 CodePromise* codePromise(Context* c, Promise* offset);
 
-Promise* shiftMaskPromise(Context* c, Promise* base, unsigned shift, int64_t mask);
+Promise* shiftMaskPromise(Context* c,
+                          Promise* base,
+                          unsigned shift,
+                          int64_t mask);
 
 Promise* combinedPromise(Context* c, Promise* low, Promise* high);
 
@@ -43,8 +45,8 @@ Promise* ipPromise(Context* c, int logicalIp);
 
 Promise* poolPromise(Context* c, int key);
 
-} // namespace compiler
-} // namespace codegen
-} // namespace avian
+}  // namespace compiler
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_COMPILER_PROMISE_H
+#endif  // AVIAN_CODEGEN_COMPILER_PROMISE_H
diff --git a/src/codegen/compiler/read.cpp b/src/codegen/compiler/read.cpp
index 9bf89b057a..3eb6564f37 100644
--- a/src/codegen/compiler/read.cpp
+++ b/src/codegen/compiler/read.cpp
@@ -20,43 +20,51 @@ namespace avian {
 namespace codegen {
 namespace compiler {
 
+SingleRead::SingleRead(const SiteMask& mask, Value* successor)
+    : next_(0), mask(mask), high_(0), successor_(successor)
+{
+}
 
-SingleRead::SingleRead(const SiteMask& mask, Value* successor):
-  next_(0), mask(mask), high_(0), successor_(successor)
-{ }
-
-bool SingleRead::intersect(SiteMask* mask, unsigned) {
+bool SingleRead::intersect(SiteMask* mask, unsigned)
+{
   *mask = mask->intersectionWith(this->mask);
 
   return true;
 }
 
-Value* SingleRead::high(Context*) {
+Value* SingleRead::high(Context*)
+{
   return high_;
 }
 
-Value* SingleRead::successor() {
+Value* SingleRead::successor()
+{
   return successor_;
 }
 
-bool SingleRead::valid() {
+bool SingleRead::valid()
+{
   return true;
 }
 
-void SingleRead::append(Context* c UNUSED, Read* r) {
+void SingleRead::append(Context* c UNUSED, Read* r)
+{
   assertT(c, next_ == 0);
   next_ = r;
 }
 
-Read* SingleRead::next(Context*) {
+Read* SingleRead::next(Context*)
+{
   return next_;
 }
 
-MultiRead::MultiRead():
-  reads(0), lastRead(0), firstTarget(0), lastTarget(0), visited(false)
-{ }
+MultiRead::MultiRead()
+    : reads(0), lastRead(0), firstTarget(0), lastTarget(0), visited(false)
+{
+}
 
-bool MultiRead::intersect(SiteMask* mask, unsigned depth) {
+bool MultiRead::intersect(SiteMask* mask, unsigned depth)
+{
   if (depth > 0) {
     // short-circuit recursion to avoid poor performance in
     // deeply-nested branches
@@ -81,11 +89,13 @@ bool MultiRead::intersect(SiteMask* mask, unsigned depth) {
   return result;
 }
 
-Value* MultiRead::successor() {
+Value* MultiRead::successor()
+{
   return 0;
 }
 
-bool MultiRead::valid() {
+bool MultiRead::valid()
+{
   bool result = false;
   if (not visited) {
     visited = true;
@@ -103,7 +113,8 @@ bool MultiRead::valid() {
   return result;
 }
 
-void MultiRead::append(Context* c, Read* r) {
+void MultiRead::append(Context* c, Read* r)
+{
   List<Read*>* cell = cons<Read*>(c, r, 0);
   if (lastRead == 0) {
     reads = cell;
@@ -112,19 +123,21 @@ void MultiRead::append(Context* c, Read* r) {
   }
   lastRead = cell;
 
-//     fprintf(stderr, "append %p to %p for %p\n", r, lastTarget, this);
+  //     fprintf(stderr, "append %p to %p for %p\n", r, lastTarget, this);
 
   lastTarget->item = r;
 }
 
-Read* MultiRead::next(Context* c) {
+Read* MultiRead::next(Context* c)
+{
   abort(c);
 }
 
-void MultiRead::allocateTarget(Context* c) {
+void MultiRead::allocateTarget(Context* c)
+{
   List<Read*>* cell = cons<Read*>(c, 0, 0);
 
-//     fprintf(stderr, "allocate target for %p: %p\n", this, cell);
+  //     fprintf(stderr, "allocate target for %p: %p\n", this, cell);
 
   if (lastTarget) {
     lastTarget->next = cell;
@@ -134,7 +147,8 @@ void MultiRead::allocateTarget(Context* c) {
   lastTarget = cell;
 }
 
-Read* MultiRead::nextTarget() {
+Read* MultiRead::nextTarget()
+{
   //     fprintf(stderr, "next target for %p: %p\n", this, firstTarget);
 
   Read* r = firstTarget->item;
@@ -142,12 +156,12 @@ Read* MultiRead::nextTarget() {
   return r;
 }
 
+StubRead::StubRead() : next_(0), read(0), visited(false), valid_(true)
+{
+}
 
-StubRead::StubRead():
-  next_(0), read(0), visited(false), valid_(true)
-{ }
-
-bool StubRead::intersect(SiteMask* mask, unsigned depth) {
+bool StubRead::intersect(SiteMask* mask, unsigned depth)
+{
   if (not visited) {
     visited = true;
     if (read) {
@@ -161,32 +175,35 @@ bool StubRead::intersect(SiteMask* mask, unsigned depth) {
   return valid_;
 }
 
-Value* StubRead::successor() {
+Value* StubRead::successor()
+{
   return 0;
 }
 
-bool StubRead::valid() {
+bool StubRead::valid()
+{
   return valid_;
 }
 
-void StubRead::append(Context* c UNUSED, Read* r) {
+void StubRead::append(Context* c UNUSED, Read* r)
+{
   assertT(c, next_ == 0);
   next_ = r;
 }
 
-Read* StubRead::next(Context*) {
+Read* StubRead::next(Context*)
+{
   return next_;
 }
 
-
-
-SingleRead* read(Context* c, const SiteMask& mask, Value* successor) {
+SingleRead* read(Context* c, const SiteMask& mask, Value* successor)
+{
   assertT(c,
           (mask.typeMask != 1 << lir::MemoryOperand) or mask.frameIndex >= 0);
 
-  return new(c->zone) SingleRead(mask, successor);
+  return new (c->zone) SingleRead(mask, successor);
 }
 
-} // namespace compiler
-} // namespace codegen
-} // namespace avian
+}  // namespace compiler
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/compiler/read.h b/src/codegen/compiler/read.h
index 0e6f42a4e5..7941bbeb3f 100644
--- a/src/codegen/compiler/read.h
+++ b/src/codegen/compiler/read.h
@@ -22,16 +22,19 @@ class Event;
 
 class Read {
  public:
-  Read():
-    value(0), event(0), eventNext(0)
-  { }
+  Read() : value(0), event(0), eventNext(0)
+  {
+  }
 
   virtual bool intersect(SiteMask* mask, unsigned depth = 0) = 0;
 
-  virtual Value* high(Context* c) { abort(c); }
+  virtual Value* high(Context* c)
+  {
+    abort(c);
+  }
 
   virtual Value* successor() = 0;
-  
+
   virtual bool valid() = 0;
 
   virtual void append(Context* c, Read* r) = 0;
@@ -43,11 +46,12 @@ class Read {
   Read* eventNext;
 };
 
-inline bool valid(Read* r) {
+inline bool valid(Read* r)
+{
   return r and r->valid();
 }
 
-class SingleRead: public Read {
+class SingleRead : public Read {
  public:
   SingleRead(const SiteMask& mask, Value* successor);
 
@@ -56,7 +60,7 @@ class SingleRead: public Read {
   virtual Value* high(Context*);
 
   virtual Value* successor();
-  
+
   virtual bool valid();
 
   virtual void append(Context* c UNUSED, Read* r);
@@ -69,8 +73,7 @@ class SingleRead: public Read {
   Value* successor_;
 };
 
-
-class MultiRead: public Read {
+class MultiRead : public Read {
  public:
   MultiRead();
 
@@ -95,7 +98,7 @@ class MultiRead: public Read {
   bool visited;
 };
 
-class StubRead: public Read {
+class StubRead : public Read {
  public:
   StubRead();
 
@@ -117,9 +120,8 @@ class StubRead: public Read {
 
 SingleRead* read(Context* c, const SiteMask& mask, Value* successor = 0);
 
+}  // namespace compiler
+}  // namespace codegen
+}  // namespace avian
 
-} // namespace compiler
-} // namespace codegen
-} // namespace avian
-
-#endif // AVIAN_CODEGEN_COMPILER_READ_H
+#endif  // AVIAN_CODEGEN_COMPILER_READ_H
diff --git a/src/codegen/compiler/regalloc.cpp b/src/codegen/compiler/regalloc.cpp
index b9c245e653..6f716df770 100644
--- a/src/codegen/compiler/regalloc.cpp
+++ b/src/codegen/compiler/regalloc.cpp
@@ -20,24 +20,25 @@ namespace avian {
 namespace codegen {
 namespace compiler {
 
-RegisterAllocator::RegisterAllocator(Aborter* a, const RegisterFile* registerFile):
-  a(a),
-  registerFile(registerFile)
-{ }
-
+RegisterAllocator::RegisterAllocator(Aborter* a,
+                                     const RegisterFile* registerFile)
+    : a(a), registerFile(registerFile)
+{
+}
 
 unsigned totalFrameSize(Context* c);
 Read* live(Context* c UNUSED, Value* v);
 
-unsigned
-resourceCost(Context* c, Value* v, Resource* r, SiteMask mask,
-             CostCalculator* costCalculator)
+unsigned resourceCost(Context* c,
+                      Value* v,
+                      Resource* r,
+                      SiteMask mask,
+                      CostCalculator* costCalculator)
 {
   if (r->reserved or r->freezeCount or r->referenceCount) {
     return Target::Impossible;
-  } else {    
-    unsigned baseCost =
-      costCalculator ? costCalculator->cost(c, mask) : 0;
+  } else {
+    unsigned baseCost = costCalculator ? costCalculator->cost(c, mask) : 0;
 
     if (r->value) {
       assertT(c, r->value->findSite(r->site));
@@ -55,15 +56,23 @@ resourceCost(Context* c, Value* v, Resource* r, SiteMask mask,
   }
 }
 
-bool
-pickRegisterTarget(Context* c, int i, Value* v, uint32_t mask, int* target,
-                   unsigned* cost, CostCalculator* costCalculator)
+bool pickRegisterTarget(Context* c,
+                        int i,
+                        Value* v,
+                        uint32_t mask,
+                        int* target,
+                        unsigned* cost,
+                        CostCalculator* costCalculator)
 {
   if ((1 << i) & mask) {
     RegisterResource* r = c->registerResources + i;
-    unsigned myCost = resourceCost
-      (c, v, r, SiteMask(1 << lir::RegisterOperand, 1 << i, NoFrameIndex), costCalculator)
-      + Target::MinimumRegisterCost;
+    unsigned myCost
+        = resourceCost(
+              c,
+              v,
+              r,
+              SiteMask(1 << lir::RegisterOperand, 1 << i, NoFrameIndex),
+              costCalculator) + Target::MinimumRegisterCost;
 
     if ((static_cast<uint32_t>(1) << i) == mask) {
       *cost = myCost;
@@ -76,17 +85,19 @@ pickRegisterTarget(Context* c, int i, Value* v, uint32_t mask, int* target,
   return false;
 }
 
-int
-pickRegisterTarget(Context* c, Value* v, uint32_t mask, unsigned* cost,
-                   CostCalculator* costCalculator)
+int pickRegisterTarget(Context* c,
+                       Value* v,
+                       uint32_t mask,
+                       unsigned* cost,
+                       CostCalculator* costCalculator)
 {
   int target = lir::NoRegister;
   *cost = Target::Impossible;
 
   if (mask & c->regFile->generalRegisters.mask) {
     for (int i = c->regFile->generalRegisters.limit - 1;
-         i >= c->regFile->generalRegisters.start; --i)
-    {
+         i >= c->regFile->generalRegisters.start;
+         --i) {
       if (pickRegisterTarget(c, i, v, mask, &target, cost, costCalculator)) {
         return i;
       }
@@ -95,8 +106,8 @@ pickRegisterTarget(Context* c, Value* v, uint32_t mask, unsigned* cost,
 
   if (mask & c->regFile->floatRegisters.mask) {
     for (int i = c->regFile->floatRegisters.start;
-         i < static_cast<int>(c->regFile->floatRegisters.limit); ++i)
-    {
+         i < static_cast<int>(c->regFile->floatRegisters.limit);
+         ++i) {
       if (pickRegisterTarget(c, i, v, mask, &target, cost, costCalculator)) {
         return i;
       }
@@ -106,34 +117,38 @@ pickRegisterTarget(Context* c, Value* v, uint32_t mask, unsigned* cost,
   return target;
 }
 
-Target
-pickRegisterTarget(Context* c, Value* v, uint32_t mask,
-                   CostCalculator* costCalculator)
+Target pickRegisterTarget(Context* c,
+                          Value* v,
+                          uint32_t mask,
+                          CostCalculator* costCalculator)
 {
   unsigned cost;
   int number = pickRegisterTarget(c, v, mask, &cost, costCalculator);
   return Target(number, lir::RegisterOperand, cost);
 }
 
-unsigned
-frameCost(Context* c, Value* v, int frameIndex, CostCalculator* costCalculator)
+unsigned frameCost(Context* c,
+                   Value* v,
+                   int frameIndex,
+                   CostCalculator* costCalculator)
 {
-  return resourceCost
-    (c, v, c->frameResources + frameIndex, SiteMask(1 << lir::MemoryOperand, 0, frameIndex),
-     costCalculator)
-    + Target::MinimumFrameCost;
+  return resourceCost(c,
+                      v,
+                      c->frameResources + frameIndex,
+                      SiteMask(1 << lir::MemoryOperand, 0, frameIndex),
+                      costCalculator) + Target::MinimumFrameCost;
 }
 
-Target
-pickFrameTarget(Context* c, Value* v, CostCalculator* costCalculator)
+Target pickFrameTarget(Context* c, Value* v, CostCalculator* costCalculator)
 {
   Target best;
 
   Value* p = v;
   do {
     if (p->home >= 0) {
-      Target mine
-        (p->home, lir::MemoryOperand, frameCost(c, v, p->home, costCalculator));
+      Target mine(p->home,
+                  lir::MemoryOperand,
+                  frameCost(c, v, p->home, costCalculator));
 
       if (mine.cost == Target::MinimumFrameCost) {
         return mine;
@@ -147,8 +162,7 @@ pickFrameTarget(Context* c, Value* v, CostCalculator* costCalculator)
   return best;
 }
 
-Target
-pickAnyFrameTarget(Context* c, Value* v, CostCalculator* costCalculator)
+Target pickAnyFrameTarget(Context* c, Value* v, CostCalculator* costCalculator)
 {
   Target best;
 
@@ -159,20 +173,22 @@ pickAnyFrameTarget(Context* c, Value* v, CostCalculator* costCalculator)
       return mine;
     } else if (mine.cost < best.cost) {
       best = mine;
-    }    
+    }
   }
 
   return best;
 }
 
-Target
-pickTarget(Context* c, Value* value, const SiteMask& mask,
-           unsigned registerPenalty, Target best,
-           CostCalculator* costCalculator)
+Target pickTarget(Context* c,
+                  Value* value,
+                  const SiteMask& mask,
+                  unsigned registerPenalty,
+                  Target best,
+                  CostCalculator* costCalculator)
 {
   if (mask.typeMask & (1 << lir::RegisterOperand)) {
-    Target mine = pickRegisterTarget
-      (c, value, mask.registerMask, costCalculator);
+    Target mine
+        = pickRegisterTarget(c, value, mask.registerMask, costCalculator);
 
     mine.cost += registerPenalty;
     if (mine.cost == Target::MinimumRegisterCost) {
@@ -184,7 +200,8 @@ pickTarget(Context* c, Value* value, const SiteMask& mask,
 
   if (mask.typeMask & (1 << lir::MemoryOperand)) {
     if (mask.frameIndex >= 0) {
-      Target mine(mask.frameIndex, lir::MemoryOperand,
+      Target mine(mask.frameIndex,
+                  lir::MemoryOperand,
                   frameCost(c, value, mask.frameIndex, costCalculator));
       if (mine.cost == Target::MinimumFrameCost) {
         return mine;
@@ -204,13 +221,16 @@ pickTarget(Context* c, Value* value, const SiteMask& mask,
   return best;
 }
 
-Target
-pickTarget(Context* c, Read* read, bool intersectRead,
-           unsigned registerReserveCount, CostCalculator* costCalculator)
+Target pickTarget(Context* c,
+                  Read* read,
+                  bool intersectRead,
+                  unsigned registerReserveCount,
+                  CostCalculator* costCalculator)
 {
   unsigned registerPenalty
-    = (c->availableGeneralRegisterCount > registerReserveCount
-       ? 0 : Target::LowRegisterPenalty);
+      = (c->availableGeneralRegisterCount > registerReserveCount
+             ? 0
+             : Target::LowRegisterPenalty);
 
   Value* value = read->value;
 
@@ -235,8 +255,8 @@ pickTarget(Context* c, Read* read, bool intersectRead,
     if (r) {
       SiteMask intersection = mask;
       if (r->intersect(&intersection)) {
-        best = pickTarget
-          (c, value, intersection, registerPenalty, best, costCalculator);
+        best = pickTarget(
+            c, value, intersection, registerPenalty, best, costCalculator);
 
         if (best.cost <= Target::MinimumFrameCost) {
           return best;
@@ -252,14 +272,18 @@ pickTarget(Context* c, Read* read, bool intersectRead,
 
   if (intersectRead) {
     if (best.cost == Target::Impossible) {
-      fprintf(stderr, "mask type %d reg %d frame %d\n",
-              mask.typeMask, mask.registerMask, mask.frameIndex);
+      fprintf(stderr,
+              "mask type %d reg %d frame %d\n",
+              mask.typeMask,
+              mask.registerMask,
+              mask.frameIndex);
       abort(c);
     }
     return best;
   }
 
-  { Target mine = pickRegisterTarget(c, value, registerMask, costCalculator);
+  {
+    Target mine = pickRegisterTarget(c, value, registerMask, costCalculator);
 
     mine.cost += registerPenalty;
 
@@ -270,7 +294,8 @@ pickTarget(Context* c, Read* read, bool intersectRead,
     }
   }
 
-  { Target mine = pickFrameTarget(c, value, costCalculator);
+  {
+    Target mine = pickFrameTarget(c, value, costCalculator);
     if (mine.cost == Target::MinimumFrameCost) {
       return mine;
     } else if (mine.cost < best.cost) {
@@ -279,8 +304,7 @@ pickTarget(Context* c, Read* read, bool intersectRead,
   }
 
   if (best.cost >= Target::StealUniquePenalty
-      and c->availableGeneralRegisterCount == 0)
-  {
+      and c->availableGeneralRegisterCount == 0) {
     // there are no free registers left, so moving from memory to
     // memory isn't an option - try harder to find an available frame
     // site:
@@ -295,6 +319,6 @@ pickTarget(Context* c, Read* read, bool intersectRead,
   return best;
 }
 
-} // namespace regalloc
-} // namespace codegen
-} // namespace avian
+}  // namespace regalloc
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/compiler/regalloc.h b/src/codegen/compiler/regalloc.h
index e7d4a3d7d2..3c87b20c00 100644
--- a/src/codegen/compiler/regalloc.h
+++ b/src/codegen/compiler/regalloc.h
@@ -20,7 +20,7 @@ namespace avian {
 
 namespace util {
 class Aborter;
-} // namespace util
+}  // namespace util
 
 namespace codegen {
 namespace compiler {
@@ -33,14 +33,12 @@ class SiteMask;
 class Resource;
 class Read;
 
-
 class RegisterAllocator {
-public:
+ public:
   Aborter* a;
   const RegisterFile* registerFile;
 
   RegisterAllocator(Aborter* a, const RegisterFile* registerFile);
-
 };
 
 class Target {
@@ -53,11 +51,14 @@ class Target {
   static const unsigned LowRegisterPenalty = 10;
   static const unsigned Impossible = 20;
 
-  Target(): cost(Impossible) { }
+  Target() : cost(Impossible)
+  {
+  }
 
-  Target(int index, lir::OperandType type, unsigned cost):
-    index(index), type(type), cost(cost)
-  { }
+  Target(int index, lir::OperandType type, unsigned cost)
+      : index(index), type(type), cost(cost)
+  {
+  }
 
   int16_t index;
   lir::OperandType type;
@@ -69,43 +70,55 @@ class CostCalculator {
   virtual unsigned cost(Context* c, SiteMask mask) = 0;
 };
 
-unsigned
-resourceCost(Context* c, Value* v, Resource* r, SiteMask mask,
-             CostCalculator* costCalculator);
+unsigned resourceCost(Context* c,
+                      Value* v,
+                      Resource* r,
+                      SiteMask mask,
+                      CostCalculator* costCalculator);
 
+bool pickRegisterTarget(Context* c,
+                        int i,
+                        Value* v,
+                        uint32_t mask,
+                        int* target,
+                        unsigned* cost,
+                        CostCalculator* costCalculator = 0);
 
-bool
-pickRegisterTarget(Context* c, int i, Value* v, uint32_t mask, int* target,
-                   unsigned* cost, CostCalculator* costCalculator = 0);
+int pickRegisterTarget(Context* c,
+                       Value* v,
+                       uint32_t mask,
+                       unsigned* cost,
+                       CostCalculator* costCalculator = 0);
 
-int
-pickRegisterTarget(Context* c, Value* v, uint32_t mask, unsigned* cost,
-                   CostCalculator* costCalculator = 0);
+Target pickRegisterTarget(Context* c,
+                          Value* v,
+                          uint32_t mask,
+                          CostCalculator* costCalculator = 0);
 
-Target
-pickRegisterTarget(Context* c, Value* v, uint32_t mask,
-                   CostCalculator* costCalculator = 0);
+unsigned frameCost(Context* c,
+                   Value* v,
+                   int frameIndex,
+                   CostCalculator* costCalculator);
 
-unsigned
-frameCost(Context* c, Value* v, int frameIndex, CostCalculator* costCalculator);
+Target pickFrameTarget(Context* c, Value* v, CostCalculator* costCalculator);
 
-Target
-pickFrameTarget(Context* c, Value* v, CostCalculator* costCalculator);
+Target pickAnyFrameTarget(Context* c, Value* v, CostCalculator* costCalculator);
 
-Target
-pickAnyFrameTarget(Context* c, Value* v, CostCalculator* costCalculator);
+Target pickTarget(Context* c,
+                  Value* value,
+                  const SiteMask& mask,
+                  unsigned registerPenalty,
+                  Target best,
+                  CostCalculator* costCalculator);
 
-Target
-pickTarget(Context* c, Value* value, const SiteMask& mask,
-           unsigned registerPenalty, Target best,
-           CostCalculator* costCalculator);
+Target pickTarget(Context* c,
+                  Read* read,
+                  bool intersectRead,
+                  unsigned registerReserveCount,
+                  CostCalculator* costCalculator);
 
-Target
-pickTarget(Context* c, Read* read, bool intersectRead,
-           unsigned registerReserveCount, CostCalculator* costCalculator);
+}  // namespace regalloc
+}  // namespace codegen
+}  // namespace avian
 
-} // namespace regalloc
-} // namespace codegen
-} // namespace avian
-
-#endif // AVIAN_CODEGEN_COMPILER_REGALLOC_H
+#endif  // AVIAN_CODEGEN_COMPILER_REGALLOC_H
diff --git a/src/codegen/compiler/resource.cpp b/src/codegen/compiler/resource.cpp
index b6b07c942e..f9a307c1dc 100644
--- a/src/codegen/compiler/resource.cpp
+++ b/src/codegen/compiler/resource.cpp
@@ -18,154 +18,173 @@ namespace compiler {
 
 const bool DebugResources = false;
 
-
 void steal(Context* c, Resource* r, Value* thief);
 
-void decrementAvailableGeneralRegisterCount(Context* c) {
+void decrementAvailableGeneralRegisterCount(Context* c)
+{
   assertT(c, c->availableGeneralRegisterCount);
-  -- c->availableGeneralRegisterCount;
-  
+  --c->availableGeneralRegisterCount;
+
   if (DebugResources) {
-    fprintf(stderr, "%d registers available\n",
-            c->availableGeneralRegisterCount);
+    fprintf(
+        stderr, "%d registers available\n", c->availableGeneralRegisterCount);
   }
 }
 
-void incrementAvailableGeneralRegisterCount(Context* c) {
-  ++ c->availableGeneralRegisterCount;
+void incrementAvailableGeneralRegisterCount(Context* c)
+{
+  ++c->availableGeneralRegisterCount;
 
   if (DebugResources) {
-    fprintf(stderr, "%d registers available\n",
-            c->availableGeneralRegisterCount);
+    fprintf(
+        stderr, "%d registers available\n", c->availableGeneralRegisterCount);
   }
 }
 
-void freezeResource(Context* c, Resource* r, Value* v) {
+void freezeResource(Context* c, Resource* r, Value* v)
+{
   if (DebugResources) {
-    char buffer[256]; r->toString(c, buffer, 256);
+    char buffer[256];
+    r->toString(c, buffer, 256);
     fprintf(stderr, "%p freeze %s to %d\n", v, buffer, r->freezeCount + 1);
   }
-    
-  ++ r->freezeCount;
+
+  ++r->freezeCount;
 }
 
-void thawResource(Context* c, Resource* r, Value* v) {
+void thawResource(Context* c, Resource* r, Value* v)
+{
   if (not r->reserved) {
     if (DebugResources) {
-      char buffer[256]; r->toString(c, buffer, 256);
+      char buffer[256];
+      r->toString(c, buffer, 256);
       fprintf(stderr, "%p thaw %s to %d\n", v, buffer, r->freezeCount - 1);
     }
 
     assertT(c, r->freezeCount);
 
-    -- r->freezeCount;
+    --r->freezeCount;
   }
 }
 
+Resource::Resource(bool reserved)
+    : value(0),
+      site(0),
+      previousAcquired(0),
+      nextAcquired(0),
+      freezeCount(0),
+      referenceCount(0),
+      reserved(reserved)
+{
+}
 
-Resource::Resource(bool reserved):
-  value(0), site(0), previousAcquired(0), nextAcquired(0), freezeCount(0),
-  referenceCount(0), reserved(reserved)
-{ }
+RegisterResource::RegisterResource(bool reserved) : Resource(reserved)
+{
+}
 
-RegisterResource::RegisterResource(bool reserved):
-  Resource(reserved)
-{ }
-
-void RegisterResource::freeze(Context* c, Value* v) {
+void RegisterResource::freeze(Context* c, Value* v)
+{
   if (not reserved) {
     freezeResource(c, this, v);
 
     if (freezeCount == 1
-        and ((1 << index(c)) & c->regFile->generalRegisters.mask))
-    {
+        and ((1 << index(c)) & c->regFile->generalRegisters.mask)) {
       decrementAvailableGeneralRegisterCount(c);
     }
   }
 }
 
-void RegisterResource::thaw(Context* c, Value* v) {
+void RegisterResource::thaw(Context* c, Value* v)
+{
   if (not reserved) {
     thawResource(c, this, v);
 
     if (freezeCount == 0
-        and ((1 << index(c)) & c->regFile->generalRegisters.mask))
-    {
+        and ((1 << index(c)) & c->regFile->generalRegisters.mask)) {
       incrementAvailableGeneralRegisterCount(c);
     }
   }
 }
 
-unsigned RegisterResource::toString(Context* c, char* buffer, unsigned bufferSize) {
+unsigned RegisterResource::toString(Context* c,
+                                    char* buffer,
+                                    unsigned bufferSize)
+{
   return vm::snprintf(buffer, bufferSize, "register %d", index(c));
 }
 
-unsigned RegisterResource::index(Context* c) {
+unsigned RegisterResource::index(Context* c)
+{
   return this - c->registerResources;
 }
 
-void RegisterResource::increment(Context* c) {
+void RegisterResource::increment(Context* c)
+{
   if (not this->reserved) {
     if (DebugResources) {
-      char buffer[256]; this->toString(c, buffer, 256);
+      char buffer[256];
+      this->toString(c, buffer, 256);
       fprintf(stderr, "increment %s to %d\n", buffer, this->referenceCount + 1);
     }
 
-    ++ this->referenceCount;
+    ++this->referenceCount;
 
     if (this->referenceCount == 1
-        and ((1 << this->index(c)) & c->regFile->generalRegisters.mask))
-    {
+        and ((1 << this->index(c)) & c->regFile->generalRegisters.mask)) {
       decrementAvailableGeneralRegisterCount(c);
     }
   }
 }
 
-void RegisterResource::decrement(Context* c) {
+void RegisterResource::decrement(Context* c)
+{
   if (not this->reserved) {
     if (DebugResources) {
-      char buffer[256]; this->toString(c, buffer, 256);
+      char buffer[256];
+      this->toString(c, buffer, 256);
       fprintf(stderr, "decrement %s to %d\n", buffer, this->referenceCount - 1);
     }
 
     assertT(c, this->referenceCount > 0);
 
-    -- this->referenceCount;
+    --this->referenceCount;
 
     if (this->referenceCount == 0
-        and ((1 << this->index(c)) & c->regFile->generalRegisters.mask))
-    {
+        and ((1 << this->index(c)) & c->regFile->generalRegisters.mask)) {
       incrementAvailableGeneralRegisterCount(c);
     }
   }
 }
 
-
-
-void FrameResource::freeze(Context* c, Value* v) {
+void FrameResource::freeze(Context* c, Value* v)
+{
   freezeResource(c, this, v);
 }
 
-void FrameResource::thaw(Context* c, Value* v) {
+void FrameResource::thaw(Context* c, Value* v)
+{
   thawResource(c, this, v);
 }
 
-unsigned FrameResource::toString(Context* c, char* buffer, unsigned bufferSize) {
+unsigned FrameResource::toString(Context* c, char* buffer, unsigned bufferSize)
+{
   return vm::snprintf(buffer, bufferSize, "frame %d", index(c));
 }
 
-unsigned FrameResource::index(Context* c) {
+unsigned FrameResource::index(Context* c)
+{
   return this - c->frameResources;
 }
 
-
-void acquire(Context* c, Resource* resource, Value* value, Site* site) {
+void acquire(Context* c, Resource* resource, Value* value, Site* site)
+{
   assertT(c, value);
   assertT(c, site);
 
   if (not resource->reserved) {
     if (DebugResources) {
-      char buffer[256]; resource->toString(c, buffer, 256);
+      char buffer[256];
+      resource->toString(c, buffer, 256);
       fprintf(stderr, "%p acquire %s\n", value, buffer);
     }
 
@@ -178,7 +197,7 @@ void acquire(Context* c, Resource* resource, Value* value, Site* site) {
 
     if (c->acquiredResources) {
       c->acquiredResources->previousAcquired = resource;
-      resource->nextAcquired = c->acquiredResources;        
+      resource->nextAcquired = c->acquiredResources;
     }
     c->acquiredResources = resource;
 
@@ -187,10 +206,15 @@ void acquire(Context* c, Resource* resource, Value* value, Site* site) {
   }
 }
 
-void release(Context* c, Resource* resource, Value* value UNUSED, Site* site UNUSED) {
+void release(Context* c,
+             Resource* resource,
+             Value* value UNUSED,
+             Site* site UNUSED)
+{
   if (not resource->reserved) {
     if (DebugResources) {
-      char buffer[256]; resource->toString(c, buffer, 256);
+      char buffer[256];
+      resource->toString(c, buffer, 256);
       fprintf(stderr, "%p release %s\n", resource->value, buffer);
     }
 
@@ -214,13 +238,12 @@ void release(Context* c, Resource* resource, Value* value UNUSED, Site* site UNU
       assertT(c, c->acquiredResources == resource);
       c->acquiredResources = next;
     }
-    
+
     resource->value = 0;
     resource->site = 0;
   }
 }
 
-
-} // namespace compiler
-} // namespace codegen
+}  // namespace compiler
+}  // namespace codegen
 }  // namespace avian
diff --git a/src/codegen/compiler/resource.h b/src/codegen/compiler/resource.h
index 8c2c7f7b25..1712871079 100644
--- a/src/codegen/compiler/resource.h
+++ b/src/codegen/compiler/resource.h
@@ -38,7 +38,7 @@ class Resource {
   bool reserved;
 };
 
-class RegisterResource: public Resource {
+class RegisterResource : public Resource {
  public:
   RegisterResource(bool reserved);
 
@@ -55,7 +55,7 @@ class RegisterResource: public Resource {
   void decrement(Context*);
 };
 
-class FrameResource: public Resource {
+class FrameResource : public Resource {
  public:
   virtual void freeze(Context*, Value*);
 
@@ -70,8 +70,8 @@ void acquire(Context* c, Resource* resource, Value* value, Site* site);
 
 void release(Context* c, Resource* resource, Value* value, Site* site);
 
-} // namespace compiler
-} // namespace codegen
-} // namespace avian
+}  // namespace compiler
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_COMPILER_RESOURCE_H
+#endif  // AVIAN_CODEGEN_COMPILER_RESOURCE_H
diff --git a/src/codegen/compiler/site.cpp b/src/codegen/compiler/site.cpp
index 9501083504..ea762a851f 100644
--- a/src/codegen/compiler/site.cpp
+++ b/src/codegen/compiler/site.cpp
@@ -21,35 +21,43 @@ namespace avian {
 namespace codegen {
 namespace compiler {
 
-
-
-int intersectFrameIndexes(int a, int b) {
-  if (a == NoFrameIndex or b == NoFrameIndex) return NoFrameIndex;
-  if (a == AnyFrameIndex) return b;
-  if (b == AnyFrameIndex) return a;
-  if (a == b) return a;
+int intersectFrameIndexes(int a, int b)
+{
+  if (a == NoFrameIndex or b == NoFrameIndex)
+    return NoFrameIndex;
+  if (a == AnyFrameIndex)
+    return b;
+  if (b == AnyFrameIndex)
+    return a;
+  if (a == b)
+    return a;
   return NoFrameIndex;
 }
 
-
-SiteMask SiteMask::intersectionWith(const SiteMask& b) {
-  return SiteMask(typeMask & b.typeMask, registerMask & b.registerMask,
+SiteMask SiteMask::intersectionWith(const SiteMask& b)
+{
+  return SiteMask(typeMask & b.typeMask,
+                  registerMask & b.registerMask,
                   intersectFrameIndexes(frameIndex, b.frameIndex));
 }
 
-SiteIterator::SiteIterator(Context* c, Value* v, bool includeBuddies,
-             bool includeNextWord):
-  c(c),
-  originalValue(v),
-  currentValue(v),
-  includeBuddies(includeBuddies),
-  includeNextWord(includeNextWord),
-  pass(0),
-  next_(findNext(&(v->sites))),
-  previous(0)
-{ }
+SiteIterator::SiteIterator(Context* c,
+                           Value* v,
+                           bool includeBuddies,
+                           bool includeNextWord)
+    : c(c),
+      originalValue(v),
+      currentValue(v),
+      includeBuddies(includeBuddies),
+      includeNextWord(includeNextWord),
+      pass(0),
+      next_(findNext(&(v->sites))),
+      previous(0)
+{
+}
 
-Site** SiteIterator::findNext(Site** p) {
+Site** SiteIterator::findNext(Site** p)
+{
   while (true) {
     if (*p) {
       if (pass == 0 or (*p)->registerSize(c) > c->targetInfo.pointerSize) {
@@ -83,7 +91,8 @@ Site** SiteIterator::findNext(Site** p) {
   }
 }
 
-bool SiteIterator::hasMore() {
+bool SiteIterator::hasMore()
+{
   if (previous) {
     next_ = findNext(&((*previous)->next));
     previous = 0;
@@ -91,12 +100,14 @@ bool SiteIterator::hasMore() {
   return next_ != 0;
 }
 
-Site* SiteIterator::next() {
+Site* SiteIterator::next()
+{
   previous = next_;
   return *previous;
 }
 
-void SiteIterator::remove(Context* c) {
+void SiteIterator::remove(Context* c)
+{
   (*previous)->release(c, originalValue);
   *previous = (*previous)->next;
   next_ = findNext(previous);
@@ -108,50 +119,59 @@ unsigned Site::registerSize(Context* c)
   return c->targetInfo.pointerSize;
 }
 
-Site* constantSite(Context* c, Promise* value) {
-  return new(c->zone) ConstantSite(value);
+Site* constantSite(Context* c, Promise* value)
+{
+  return new (c->zone) ConstantSite(value);
 }
 
-Site* constantSite(Context* c, int64_t value) {
+Site* constantSite(Context* c, int64_t value)
+{
   return constantSite(c, resolvedPromise(c, value));
 }
 
-
-
-class AddressSite: public Site {
+class AddressSite : public Site {
  public:
-  AddressSite(Promise* address): address(address) { }
+  AddressSite(Promise* address) : address(address)
+  {
+  }
 
-  virtual unsigned toString(Context*, char* buffer, unsigned bufferSize) {
+  virtual unsigned toString(Context*, char* buffer, unsigned bufferSize)
+  {
     if (address->resolved()) {
-      return vm::snprintf
-        (buffer, bufferSize, "address %" LLD, address->value());
+      return vm::snprintf(
+          buffer, bufferSize, "address %" LLD, address->value());
     } else {
       return vm::snprintf(buffer, bufferSize, "address unresolved");
     }
   }
 
-  virtual unsigned copyCost(Context*, Site* s) {
+  virtual unsigned copyCost(Context*, Site* s)
+  {
     return (s == this ? 0 : AddressCopyCost);
   }
 
-  virtual bool match(Context*, const SiteMask& mask) {
+  virtual bool match(Context*, const SiteMask& mask)
+  {
     return mask.typeMask & (1 << lir::AddressOperand);
   }
 
-  virtual bool loneMatch(Context*, const SiteMask&) {
+  virtual bool loneMatch(Context*, const SiteMask&)
+  {
     return false;
   }
 
-  virtual bool matchNextWord(Context* c, Site*, unsigned) {
+  virtual bool matchNextWord(Context* c, Site*, unsigned)
+  {
     abort(c);
   }
 
-  virtual lir::OperandType type(Context*) {
+  virtual lir::OperandType type(Context*)
+  {
     return lir::AddressOperand;
   }
 
-  virtual void asAssemblerOperand(Context* c UNUSED, Site* high UNUSED,
+  virtual void asAssemblerOperand(Context* c UNUSED,
+                                  Site* high UNUSED,
                                   lir::Operand* result)
   {
     assertT(c, high == this);
@@ -159,66 +179,74 @@ class AddressSite: public Site {
     new (result) lir::Address(address);
   }
 
-  virtual Site* copy(Context* c) {
+  virtual Site* copy(Context* c)
+  {
     return addressSite(c, address);
   }
 
-  virtual Site* copyLow(Context* c) {
+  virtual Site* copyLow(Context* c)
+  {
     abort(c);
   }
 
-  virtual Site* copyHigh(Context* c) {
+  virtual Site* copyHigh(Context* c)
+  {
     abort(c);
   }
 
-  virtual Site* makeNextWord(Context* c, unsigned) {
+  virtual Site* makeNextWord(Context* c, unsigned)
+  {
     abort(c);
   }
 
-  virtual SiteMask mask(Context*) {
+  virtual SiteMask mask(Context*)
+  {
     return SiteMask(1 << lir::AddressOperand, 0, NoFrameIndex);
   }
 
-  virtual SiteMask nextWordMask(Context* c, unsigned) {
+  virtual SiteMask nextWordMask(Context* c, unsigned)
+  {
     abort(c);
   }
 
   Promise* address;
 };
 
-Site* addressSite(Context* c, Promise* address) {
-  return new(c->zone) AddressSite(address);
+Site* addressSite(Context* c, Promise* address)
+{
+  return new (c->zone) AddressSite(address);
 }
 
+RegisterSite::RegisterSite(uint32_t mask, int number)
+    : mask_(mask), number(number)
+{
+}
 
-RegisterSite::RegisterSite(uint32_t mask, int number):
-  mask_(mask), number(number)
-{ }
-
-unsigned RegisterSite::toString(Context*, char* buffer, unsigned bufferSize) {
+unsigned RegisterSite::toString(Context*, char* buffer, unsigned bufferSize)
+{
   if (number != lir::NoRegister) {
     return vm::snprintf(buffer, bufferSize, "%p register %d", this, number);
   } else {
-    return vm::snprintf(buffer, bufferSize,
-                        "%p register unacquired (mask %d)", this, mask_);
+    return vm::snprintf(
+        buffer, bufferSize, "%p register unacquired (mask %d)", this, mask_);
   }
 }
 
-unsigned RegisterSite::copyCost(Context* c, Site* s) {
+unsigned RegisterSite::copyCost(Context* c, Site* s)
+{
   assertT(c, number != lir::NoRegister);
 
-  if (s and
-      (this == s or
-       (s->type(c) == lir::RegisterOperand
-        and (static_cast<RegisterSite*>(s)->mask_ & (1 << number)))))
-  {
+  if (s and (this == s
+             or (s->type(c) == lir::RegisterOperand
+                 and (static_cast<RegisterSite*>(s)->mask_ & (1 << number))))) {
     return 0;
   } else {
     return RegisterCopyCost;
   }
 }
 
-bool RegisterSite::match(Context* c UNUSED, const SiteMask& mask) {
+bool RegisterSite::match(Context* c UNUSED, const SiteMask& mask)
+{
   assertT(c, number != lir::NoRegister);
 
   if ((mask.typeMask & (1 << lir::RegisterOperand))) {
@@ -228,7 +256,8 @@ bool RegisterSite::match(Context* c UNUSED, const SiteMask& mask) {
   }
 }
 
-bool RegisterSite::loneMatch(Context* c UNUSED, const SiteMask& mask) {
+bool RegisterSite::loneMatch(Context* c UNUSED, const SiteMask& mask)
+{
   assertT(c, number != lir::NoRegister);
 
   if ((mask.typeMask & (1 << lir::RegisterOperand))) {
@@ -238,7 +267,8 @@ bool RegisterSite::loneMatch(Context* c UNUSED, const SiteMask& mask) {
   }
 }
 
-bool RegisterSite::matchNextWord(Context* c, Site* s, unsigned) {
+bool RegisterSite::matchNextWord(Context* c, Site* s, unsigned)
+{
   assertT(c, number != lir::NoRegister);
 
   if (s->type(c) != lir::RegisterOperand) {
@@ -256,7 +286,8 @@ bool RegisterSite::matchNextWord(Context* c, Site* s, unsigned) {
   }
 }
 
-void RegisterSite::acquire(Context* c, Value* v) {
+void RegisterSite::acquire(Context* c, Value* v)
+{
   Target target;
   if (number != lir::NoRegister) {
     target = Target(number, lir::RegisterOperand, 0);
@@ -271,36 +302,42 @@ void RegisterSite::acquire(Context* c, Value* v) {
   number = target.index;
 }
 
-void RegisterSite::release(Context* c, Value* v) {
+void RegisterSite::release(Context* c, Value* v)
+{
   assertT(c, number != lir::NoRegister);
 
   compiler::release(c, c->registerResources + number, v, this);
 }
 
-void RegisterSite::freeze(Context* c, Value* v) {
+void RegisterSite::freeze(Context* c, Value* v)
+{
   assertT(c, number != lir::NoRegister);
 
   c->registerResources[number].freeze(c, v);
 }
 
-void RegisterSite::thaw(Context* c, Value* v) {
+void RegisterSite::thaw(Context* c, Value* v)
+{
   assertT(c, number != lir::NoRegister);
 
   c->registerResources[number].thaw(c, v);
 }
 
-bool RegisterSite::frozen(Context* c UNUSED) {
+bool RegisterSite::frozen(Context* c UNUSED)
+{
   assertT(c, number != lir::NoRegister);
 
   return c->registerResources[number].freezeCount != 0;
 }
 
-lir::OperandType RegisterSite::type(Context*) {
+lir::OperandType RegisterSite::type(Context*)
+{
   return lir::RegisterOperand;
 }
 
-void RegisterSite::asAssemblerOperand(Context* c UNUSED, Site* high,
-                                lir::Operand* result)
+void RegisterSite::asAssemblerOperand(Context* c UNUSED,
+                                      Site* high,
+                                      lir::Operand* result)
 {
   assertT(c, number != lir::NoRegister);
 
@@ -315,9 +352,10 @@ void RegisterSite::asAssemblerOperand(Context* c UNUSED, Site* high,
   new (result) lir::Register(number, highNumber);
 }
 
-Site* RegisterSite::copy(Context* c) {
+Site* RegisterSite::copy(Context* c)
+{
   uint32_t mask;
-  
+
   if (number != lir::NoRegister) {
     mask = 1 << number;
   } else {
@@ -327,38 +365,44 @@ Site* RegisterSite::copy(Context* c) {
   return freeRegisterSite(c, mask);
 }
 
-Site* RegisterSite::copyLow(Context* c) {
+Site* RegisterSite::copyLow(Context* c)
+{
   abort(c);
 }
 
-Site* RegisterSite::copyHigh(Context* c) {
+Site* RegisterSite::copyHigh(Context* c)
+{
   abort(c);
 }
 
-Site* RegisterSite::makeNextWord(Context* c, unsigned) {
+Site* RegisterSite::makeNextWord(Context* c, unsigned)
+{
   assertT(c, number != lir::NoRegister);
   assertT(c, ((1 << number) & c->regFile->generalRegisters.mask));
 
-  return freeRegisterSite(c, c->regFile->generalRegisters.mask);    
+  return freeRegisterSite(c, c->regFile->generalRegisters.mask);
 }
 
-SiteMask RegisterSite::mask(Context* c UNUSED) {
+SiteMask RegisterSite::mask(Context* c UNUSED)
+{
   return SiteMask(1 << lir::RegisterOperand, mask_, NoFrameIndex);
 }
 
-SiteMask RegisterSite::nextWordMask(Context* c, unsigned) {
+SiteMask RegisterSite::nextWordMask(Context* c, unsigned)
+{
   assertT(c, number != lir::NoRegister);
 
   if (registerSize(c) > c->targetInfo.pointerSize) {
-    return SiteMask
-      (1 << lir::RegisterOperand, number, NoFrameIndex);
+    return SiteMask(1 << lir::RegisterOperand, number, NoFrameIndex);
   } else {
-    return SiteMask
-      (1 << lir::RegisterOperand, c->regFile->generalRegisters.mask, NoFrameIndex);
+    return SiteMask(1 << lir::RegisterOperand,
+                    c->regFile->generalRegisters.mask,
+                    NoFrameIndex);
   }
 }
 
-unsigned RegisterSite::registerSize(Context* c) {
+unsigned RegisterSite::registerSize(Context* c)
+{
   assertT(c, number != lir::NoRegister);
 
   if ((1 << number) & c->regFile->floatRegisters.mask) {
@@ -368,65 +412,68 @@ unsigned RegisterSite::registerSize(Context* c) {
   }
 }
 
-unsigned RegisterSite::registerMask(Context* c UNUSED) {
+unsigned RegisterSite::registerMask(Context* c UNUSED)
+{
   assertT(c, number != lir::NoRegister);
 
   return 1 << number;
 }
 
-
-
-Site* registerSite(Context* c, int number) {
+Site* registerSite(Context* c, int number)
+{
   assertT(c, number >= 0);
   assertT(c,
           (1 << number) & (c->regFile->generalRegisters.mask
                            | c->regFile->floatRegisters.mask));
 
-  return new(c->zone) RegisterSite(1 << number, number);
+  return new (c->zone) RegisterSite(1 << number, number);
 }
 
-Site* freeRegisterSite(Context* c, uint32_t mask) {
-  return new(c->zone) RegisterSite(mask, lir::NoRegister);
+Site* freeRegisterSite(Context* c, uint32_t mask)
+{
+  return new (c->zone) RegisterSite(mask, lir::NoRegister);
 }
 
-MemorySite::MemorySite(int base, int offset, int index, unsigned scale):
-  acquired(false), base(base), offset(offset), index(index), scale(scale)
-{ }
+MemorySite::MemorySite(int base, int offset, int index, unsigned scale)
+    : acquired(false), base(base), offset(offset), index(index), scale(scale)
+{
+}
 
-unsigned MemorySite::toString(Context*, char* buffer, unsigned bufferSize) {
+unsigned MemorySite::toString(Context*, char* buffer, unsigned bufferSize)
+{
   if (acquired) {
-    return vm::snprintf(buffer, bufferSize, "memory %d 0x%x %d %d",
-                    base, offset, index, scale);
+    return vm::snprintf(
+        buffer, bufferSize, "memory %d 0x%x %d %d", base, offset, index, scale);
   } else {
     return vm::snprintf(buffer, bufferSize, "memory unacquired");
   }
 }
 
-unsigned MemorySite::copyCost(Context* c, Site* s) {
+unsigned MemorySite::copyCost(Context* c, Site* s)
+{
   assertT(c, acquired);
 
-  if (s and
-      (this == s or
-       (s->type(c) == lir::MemoryOperand
-        and static_cast<MemorySite*>(s)->base == base
-        and static_cast<MemorySite*>(s)->offset == offset
-        and static_cast<MemorySite*>(s)->index == index
-        and static_cast<MemorySite*>(s)->scale == scale)))
-  {
+  if (s and (this == s or (s->type(c) == lir::MemoryOperand
+                           and static_cast<MemorySite*>(s)->base == base
+                           and static_cast<MemorySite*>(s)->offset == offset
+                           and static_cast<MemorySite*>(s)->index == index
+                           and static_cast<MemorySite*>(s)->scale == scale))) {
     return 0;
   } else {
     return MemoryCopyCost;
   }
 }
 
-bool MemorySite::conflicts(const SiteMask& mask) {
+bool MemorySite::conflicts(const SiteMask& mask)
+{
   return (mask.typeMask & (1 << lir::RegisterOperand)) != 0
-    and (((1 << base) & mask.registerMask) == 0
-         or (index != lir::NoRegister
-             and ((1 << index) & mask.registerMask) == 0));
+         and (((1 << base) & mask.registerMask) == 0
+              or (index != lir::NoRegister
+                  and ((1 << index) & mask.registerMask) == 0));
 }
 
-bool MemorySite::match(Context* c, const SiteMask& mask) {
+bool MemorySite::match(Context* c, const SiteMask& mask)
+{
   assertT(c, acquired);
 
   if (mask.typeMask & (1 << lir::MemoryOperand)) {
@@ -434,7 +481,7 @@ bool MemorySite::match(Context* c, const SiteMask& mask) {
       if (base == c->arch->stack()) {
         assertT(c, index == lir::NoRegister);
         return static_cast<int>(frameIndexToOffset(c, mask.frameIndex))
-          == offset;
+               == offset;
       } else {
         return false;
       }
@@ -446,7 +493,8 @@ bool MemorySite::match(Context* c, const SiteMask& mask) {
   }
 }
 
-bool MemorySite::loneMatch(Context* c, const SiteMask& mask) {
+bool MemorySite::loneMatch(Context* c, const SiteMask& mask)
+{
   assertT(c, acquired);
 
   if (mask.typeMask & (1 << lir::MemoryOperand)) {
@@ -463,7 +511,8 @@ bool MemorySite::loneMatch(Context* c, const SiteMask& mask) {
   return false;
 }
 
-bool MemorySite::matchNextWord(Context* c, Site* s, unsigned index) {
+bool MemorySite::matchNextWord(Context* c, Site* s, unsigned index)
+{
   if (s->type(c) == lir::MemoryOperand) {
     MemorySite* ms = static_cast<MemorySite*>(s);
     return ms->base == this->base
@@ -481,7 +530,8 @@ bool MemorySite::matchNextWord(Context* c, Site* s, unsigned index) {
   }
 }
 
-void MemorySite::acquire(Context* c, Value* v) {
+void MemorySite::acquire(Context* c, Value* v)
+{
   c->registerResources[base].increment(c);
   if (index != lir::NoRegister) {
     c->registerResources[index].increment(c);
@@ -491,20 +541,21 @@ void MemorySite::acquire(Context* c, Value* v) {
     assertT(c, index == lir::NoRegister);
     assertT(c, not c->frameResources[offsetToFrameIndex(c, offset)].reserved);
 
-    compiler::acquire
-      (c, c->frameResources + offsetToFrameIndex(c, offset), v, this);
+    compiler::acquire(
+        c, c->frameResources + offsetToFrameIndex(c, offset), v, this);
   }
 
   acquired = true;
 }
 
-void MemorySite::release(Context* c, Value* v) {
+void MemorySite::release(Context* c, Value* v)
+{
   if (base == c->arch->stack()) {
     assertT(c, index == lir::NoRegister);
     assertT(c, not c->frameResources[offsetToFrameIndex(c, offset)].reserved);
 
-    compiler::release
-      (c, c->frameResources + offsetToFrameIndex(c, offset), v, this);
+    compiler::release(
+        c, c->frameResources + offsetToFrameIndex(c, offset), v, this);
   }
 
   c->registerResources[base].decrement(c);
@@ -515,7 +566,8 @@ void MemorySite::release(Context* c, Value* v) {
   acquired = false;
 }
 
-void MemorySite::freeze(Context* c, Value* v) {
+void MemorySite::freeze(Context* c, Value* v)
+{
   if (base == c->arch->stack()) {
     c->frameResources[offsetToFrameIndex(c, offset)].freeze(c, v);
   } else {
@@ -526,7 +578,8 @@ void MemorySite::freeze(Context* c, Value* v) {
   }
 }
 
-void MemorySite::thaw(Context* c, Value* v) {
+void MemorySite::thaw(Context* c, Value* v)
+{
   if (base == c->arch->stack()) {
     c->frameResources[offsetToFrameIndex(c, offset)].thaw(c, v);
   } else {
@@ -537,17 +590,20 @@ void MemorySite::thaw(Context* c, Value* v) {
   }
 }
 
-bool MemorySite::frozen(Context* c) {
+bool MemorySite::frozen(Context* c)
+{
   return base == c->arch->stack()
-    and c->frameResources[offsetToFrameIndex(c, offset)].freezeCount != 0;
+         and c->frameResources[offsetToFrameIndex(c, offset)].freezeCount != 0;
 }
 
-lir::OperandType MemorySite::type(Context*) {
+lir::OperandType MemorySite::type(Context*)
+{
   return lir::MemoryOperand;
 }
 
-void MemorySite::asAssemblerOperand(Context* c UNUSED, Site* high UNUSED,
-                                lir::Operand* result)
+void MemorySite::asAssemblerOperand(Context* c UNUSED,
+                                    Site* high UNUSED,
+                                    lir::Operand* result)
 {
   // todo: endianness?
   assertT(c,
@@ -563,11 +619,13 @@ void MemorySite::asAssemblerOperand(Context* c UNUSED, Site* high UNUSED,
   new (result) lir::Memory(base, offset, index, scale);
 }
 
-Site* MemorySite::copy(Context* c) {
+Site* MemorySite::copy(Context* c)
+{
   return memorySite(c, base, offset, index, scale);
 }
 
-Site* MemorySite::copyHalf(Context* c, bool add) {
+Site* MemorySite::copyHalf(Context* c, bool add)
+{
   if (add) {
     return memorySite(
         c, base, offset + c->targetInfo.pointerSize, index, scale);
@@ -576,15 +634,18 @@ Site* MemorySite::copyHalf(Context* c, bool add) {
   }
 }
 
-Site* MemorySite::copyLow(Context* c) {
+Site* MemorySite::copyLow(Context* c)
+{
   return copyHalf(c, c->arch->bigEndian());
 }
 
-Site* MemorySite::copyHigh(Context* c) {
+Site* MemorySite::copyHigh(Context* c)
+{
   return copyHalf(c, not c->arch->bigEndian());
 }
 
-Site* MemorySite::makeNextWord(Context* c, unsigned index) {
+Site* MemorySite::makeNextWord(Context* c, unsigned index)
+{
   return memorySite(c,
                     base,
                     offset + ((index == 1) xor c->arch->bigEndian()
@@ -594,39 +655,52 @@ Site* MemorySite::makeNextWord(Context* c, unsigned index) {
                     scale);
 }
 
-SiteMask MemorySite::mask(Context* c) {
-  return SiteMask(1 << lir::MemoryOperand, 0, (base == c->arch->stack())
-                  ? static_cast<int>(offsetToFrameIndex(c, offset))
-                  : NoFrameIndex);
+SiteMask MemorySite::mask(Context* c)
+{
+  return SiteMask(1 << lir::MemoryOperand,
+                  0,
+                  (base == c->arch->stack())
+                      ? static_cast<int>(offsetToFrameIndex(c, offset))
+                      : NoFrameIndex);
 }
 
-SiteMask MemorySite::nextWordMask(Context* c, unsigned index) {
+SiteMask MemorySite::nextWordMask(Context* c, unsigned index)
+{
   int frameIndex;
   if (base == c->arch->stack()) {
     assertT(c, this->index == lir::NoRegister);
     frameIndex = static_cast<int>(offsetToFrameIndex(c, offset))
-      + ((index == 1) xor c->arch->bigEndian() ? 1 : -1);
+                 + ((index == 1) xor c->arch->bigEndian() ? 1 : -1);
   } else {
     frameIndex = NoFrameIndex;
   }
   return SiteMask(1 << lir::MemoryOperand, 0, frameIndex);
 }
 
-bool MemorySite::isVolatile(Context* c) {
+bool MemorySite::isVolatile(Context* c)
+{
   return base != c->arch->stack();
 }
 
-
-MemorySite* memorySite(Context* c, int base, int offset, int index, unsigned scale) {
-  return new(c->zone) MemorySite(base, offset, index, scale);
+MemorySite* memorySite(Context* c,
+                       int base,
+                       int offset,
+                       int index,
+                       unsigned scale)
+{
+  return new (c->zone) MemorySite(base, offset, index, scale);
 }
 
-MemorySite* frameSite(Context* c, int frameIndex) {
+MemorySite* frameSite(Context* c, int frameIndex)
+{
   assertT(c, frameIndex >= 0);
-  return memorySite
-    (c, c->arch->stack(), frameIndexToOffset(c, frameIndex), lir::NoRegister, 0);
+  return memorySite(c,
+                    c->arch->stack(),
+                    frameIndexToOffset(c, frameIndex),
+                    lir::NoRegister,
+                    0);
 }
 
-} // namespace compiler
-} // namespace codegen
-} // namespace avian
+}  // namespace compiler
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/compiler/site.h b/src/codegen/compiler/site.h
index 3f762eefed..3f93d1f5dd 100644
--- a/src/codegen/compiler/site.h
+++ b/src/codegen/compiler/site.h
@@ -30,23 +30,29 @@ const unsigned CopyPenalty = 10;
 
 class SiteMask {
  public:
-  SiteMask(): typeMask(~0), registerMask(~0), frameIndex(AnyFrameIndex) { }
+  SiteMask() : typeMask(~0), registerMask(~0), frameIndex(AnyFrameIndex)
+  {
+  }
 
-  SiteMask(uint8_t typeMask, uint32_t registerMask, int frameIndex):
-    typeMask(typeMask), registerMask(registerMask), frameIndex(frameIndex)
-  { }
+  SiteMask(uint8_t typeMask, uint32_t registerMask, int frameIndex)
+      : typeMask(typeMask), registerMask(registerMask), frameIndex(frameIndex)
+  {
+  }
 
   SiteMask intersectionWith(const SiteMask& b);
 
-  static SiteMask fixedRegisterMask(int number) {
+  static SiteMask fixedRegisterMask(int number)
+  {
     return SiteMask(1 << lir::RegisterOperand, 1 << number, NoFrameIndex);
   }
 
-  static SiteMask lowPart(const OperandMask& mask) {
+  static SiteMask lowPart(const OperandMask& mask)
+  {
     return SiteMask(mask.typeMask, mask.registerMask, AnyFrameIndex);
   }
 
-  static SiteMask highPart(const OperandMask& mask) {
+  static SiteMask highPart(const OperandMask& mask)
+  {
     return SiteMask(mask.typeMask, mask.registerMask >> 32, AnyFrameIndex);
   }
 
@@ -57,9 +63,14 @@ class SiteMask {
 
 class Site {
  public:
-  Site(): next(0) { }
-  
-  virtual Site* readTarget(Context*, Read*) { return this; }
+  Site() : next(0)
+  {
+  }
+
+  virtual Site* readTarget(Context*, Read*)
+  {
+    return this;
+  }
 
   virtual unsigned toString(Context*, char*, unsigned) = 0;
 
@@ -70,16 +81,27 @@ class Site {
   virtual bool loneMatch(Context*, const SiteMask&) = 0;
 
   virtual bool matchNextWord(Context*, Site*, unsigned) = 0;
-  
-  virtual void acquire(Context*, Value*) { }
 
-  virtual void release(Context*, Value*) { }
+  virtual void acquire(Context*, Value*)
+  {
+  }
 
-  virtual void freeze(Context*, Value*) { }
+  virtual void release(Context*, Value*)
+  {
+  }
 
-  virtual void thaw(Context*, Value*) { }
+  virtual void freeze(Context*, Value*)
+  {
+  }
 
-  virtual bool frozen(Context*) { return false; }
+  virtual void thaw(Context*, Value*)
+  {
+  }
+
+  virtual bool frozen(Context*)
+  {
+    return false;
+  }
 
   virtual lir::OperandType type(Context*) = 0;
 
@@ -99,16 +121,24 @@ class Site {
 
   virtual unsigned registerSize(Context*);
 
-  virtual unsigned registerMask(Context*) { return 0; }
+  virtual unsigned registerMask(Context*)
+  {
+    return 0;
+  }
 
-  virtual bool isVolatile(Context*) { return false; }
+  virtual bool isVolatile(Context*)
+  {
+    return false;
+  }
 
   Site* next;
 };
 
 class SiteIterator {
  public:
-  SiteIterator(Context* c, Value* v, bool includeBuddies = true,
+  SiteIterator(Context* c,
+               Value* v,
+               bool includeBuddies = true,
                bool includeNextWord = true);
 
   Site** findNext(Site** p);
@@ -130,43 +160,52 @@ Site* constantSite(Context* c, Promise* value);
 Site* constantSite(Context* c, int64_t value);
 
 Promise* combinedPromise(Context* c, Promise* low, Promise* high);
-Promise* shiftMaskPromise(Context* c, Promise* base, unsigned shift, int64_t mask);
+Promise* shiftMaskPromise(Context* c,
+                          Promise* base,
+                          unsigned shift,
+                          int64_t mask);
 
-class ConstantSite: public Site {
+class ConstantSite : public Site {
  public:
-  ConstantSite(Promise* value): value(value) { }
+  ConstantSite(Promise* value) : value(value)
+  {
+  }
 
-  virtual unsigned toString(Context*, char* buffer, unsigned bufferSize) {
+  virtual unsigned toString(Context*, char* buffer, unsigned bufferSize)
+  {
     if (value->resolved()) {
-      return vm::snprintf
-        (buffer, bufferSize, "constant %" LLD, value->value());
+      return vm::snprintf(buffer, bufferSize, "constant %" LLD, value->value());
     } else {
       return vm::snprintf(buffer, bufferSize, "constant unresolved");
     }
   }
 
-  virtual unsigned copyCost(Context*, Site* s) {
+  virtual unsigned copyCost(Context*, Site* s)
+  {
     return (s == this ? 0 : ConstantCopyCost);
   }
 
-  virtual bool match(Context*, const SiteMask& mask) {
+  virtual bool match(Context*, const SiteMask& mask)
+  {
     return mask.typeMask & (1 << lir::ConstantOperand);
   }
 
-  virtual bool loneMatch(Context*, const SiteMask&) {
+  virtual bool loneMatch(Context*, const SiteMask&)
+  {
     return true;
   }
 
-  virtual bool matchNextWord(Context* c, Site* s, unsigned) {
+  virtual bool matchNextWord(Context* c, Site* s, unsigned)
+  {
     return s->type(c) == lir::ConstantOperand;
   }
 
-  virtual lir::OperandType type(Context*) {
+  virtual lir::OperandType type(Context*)
+  {
     return lir::ConstantOperand;
   }
 
-  virtual void asAssemblerOperand(Context* c, Site* high,
-                                  lir::Operand* result)
+  virtual void asAssemblerOperand(Context* c, Site* high, lir::Operand* result)
   {
     Promise* v = value;
     if (high != this) {
@@ -175,27 +214,33 @@ class ConstantSite: public Site {
     new (result) lir::Constant(v);
   }
 
-  virtual Site* copy(Context* c) {
+  virtual Site* copy(Context* c)
+  {
     return constantSite(c, value);
   }
 
-  virtual Site* copyLow(Context* c) {
+  virtual Site* copyLow(Context* c)
+  {
     return constantSite(c, shiftMaskPromise(c, value, 0, 0xFFFFFFFF));
   }
 
-  virtual Site* copyHigh(Context* c) {
+  virtual Site* copyHigh(Context* c)
+  {
     return constantSite(c, shiftMaskPromise(c, value, 32, 0xFFFFFFFF));
   }
 
-  virtual Site* makeNextWord(Context* c, unsigned) {
+  virtual Site* makeNextWord(Context* c, unsigned)
+  {
     abort(c);
   }
 
-  virtual SiteMask mask(Context*) {
+  virtual SiteMask mask(Context*)
+  {
     return SiteMask(1 << lir::ConstantOperand, 0, NoFrameIndex);
   }
 
-  virtual SiteMask nextWordMask(Context*, unsigned) {
+  virtual SiteMask nextWordMask(Context*, unsigned)
+  {
     return SiteMask(1 << lir::ConstantOperand, 0, NoFrameIndex);
   }
 
@@ -204,7 +249,7 @@ class ConstantSite: public Site {
 
 Site* addressSite(Context* c, Promise* address);
 
-class RegisterSite: public Site {
+class RegisterSite : public Site {
  public:
   RegisterSite(uint32_t mask, int number);
 
@@ -230,7 +275,8 @@ class RegisterSite: public Site {
 
   virtual lir::OperandType type(Context*);
 
-  virtual void asAssemblerOperand(Context* c UNUSED, Site* high,
+  virtual void asAssemblerOperand(Context* c UNUSED,
+                                  Site* high,
                                   lir::Operand* result);
 
   virtual Site* copy(Context* c);
@@ -256,8 +302,7 @@ class RegisterSite: public Site {
 Site* registerSite(Context* c, int number);
 Site* freeRegisterSite(Context* c, uint32_t mask);
 
-
-class MemorySite: public Site {
+class MemorySite : public Site {
  public:
   MemorySite(int base, int offset, int index, unsigned scale);
 
@@ -285,7 +330,8 @@ class MemorySite: public Site {
 
   virtual lir::OperandType type(Context*);
 
-  virtual void asAssemblerOperand(Context* c UNUSED, Site* high UNUSED,
+  virtual void asAssemblerOperand(Context* c UNUSED,
+                                  Site* high UNUSED,
                                   lir::Operand* result);
 
   virtual Site* copy(Context* c);
@@ -311,11 +357,15 @@ class MemorySite: public Site {
   unsigned scale;
 };
 
-MemorySite* memorySite(Context* c, int base, int offset = 0, int index = lir::NoRegister, unsigned scale = 1);
+MemorySite* memorySite(Context* c,
+                       int base,
+                       int offset = 0,
+                       int index = lir::NoRegister,
+                       unsigned scale = 1);
 MemorySite* frameSite(Context* c, int frameIndex);
 
-} // namespace compiler
-} // namespace codegen
-} // namespace avian
+}  // namespace compiler
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_COMPILER_SITE_H
+#endif  // AVIAN_CODEGEN_COMPILER_SITE_H
diff --git a/src/codegen/compiler/value.cpp b/src/codegen/compiler/value.cpp
index d0c4ec7776..5e90b48ae3 100644
--- a/src/codegen/compiler/value.cpp
+++ b/src/codegen/compiler/value.cpp
@@ -31,26 +31,33 @@ Value::Value(Site* site, Site* target, ir::Type type)
 {
 }
 
-bool Value::findSite(Site* site) {
+bool Value::findSite(Site* site)
+{
   for (Site* s = this->sites; s; s = s->next) {
-    if (s == site) return true;
+    if (s == site)
+      return true;
   }
   return false;
 }
 
-bool Value::isBuddyOf(Value* b) {
+bool Value::isBuddyOf(Value* b)
+{
   Value* a = this;
-  if (a == b) return true;
+  if (a == b)
+    return true;
   for (Value* p = a->buddy; p != a; p = p->buddy) {
-    if (p == b) return true;
+    if (p == b)
+      return true;
   }
   return false;
 }
 
-void Value::addSite(Context* c, Site* s) {
+void Value::addSite(Context* c, Site* s)
+{
   if (not this->findSite(s)) {
     if (DebugSites) {
-      char buffer[256]; s->toString(c, buffer, 256);
+      char buffer[256];
+      s->toString(c, buffer, 256);
       fprintf(stderr, "add site %s to %p\n", buffer, this);
     }
     s->acquire(c, this);
@@ -59,8 +66,8 @@ void Value::addSite(Context* c, Site* s) {
   }
 }
 
-
-void Value::grow(Context* c) {
+void Value::grow(Context* c)
+{
   assertT(c, this->nextWord == this);
 
   Value* next = value(c, this->type);
@@ -69,29 +76,32 @@ void Value::grow(Context* c) {
   next->wordIndex = 1;
 }
 
-
-void Value::maybeSplit(Context* c) {
+void Value::maybeSplit(Context* c)
+{
   if (this->nextWord == this) {
     this->split(c);
   }
 }
 
-void Value::split(Context* c) {
+void Value::split(Context* c)
+{
   this->grow(c);
   for (SiteIterator it(c, this); it.hasMore();) {
     Site* s = it.next();
     this->removeSite(c, s);
-    
+
     this->addSite(c, s->copyLow(c));
     this->nextWord->addSite(c, s->copyHigh(c));
   }
 }
 
-void Value::removeSite(Context* c, Site* s) {
+void Value::removeSite(Context* c, Site* s)
+{
   for (SiteIterator it(c, this); it.hasMore();) {
     if (s == it.next()) {
       if (DebugSites) {
-        char buffer[256]; s->toString(c, buffer, 256);
+        char buffer[256];
+        s->toString(c, buffer, 256);
         fprintf(stderr, "remove site %s from %p\n", buffer, this);
       }
       it.remove(c);
@@ -104,12 +114,14 @@ void Value::removeSite(Context* c, Site* s) {
   assertT(c, not this->findSite(s));
 }
 
-bool Value::hasSite(Context* c) {
+bool Value::hasSite(Context* c)
+{
   SiteIterator it(c, this);
   return it.hasMore();
 }
 
-bool Value::uniqueSite(Context* c, Site* s) {
+bool Value::uniqueSite(Context* c, Site* s)
+{
   SiteIterator it(c, this);
   Site* p UNUSED = it.next();
   if (it.hasMore()) {
@@ -126,14 +138,15 @@ bool Value::uniqueSite(Context* c, Site* s) {
       }
     } else {
       return false;
-    }    
+    }
   } else {
     assertT(c, p == s);
     return true;
   }
 }
 
-void Value::clearSites(Context* c) {
+void Value::clearSites(Context* c)
+{
   if (DebugSites) {
     fprintf(stderr, "clear sites for %p\n", this);
   }
@@ -143,9 +156,9 @@ void Value::clearSites(Context* c) {
   }
 }
 
-
 #ifndef NDEBUG
-bool Value::hasBuddy(Context* c, Value* b) {
+bool Value::hasBuddy(Context* c, Value* b)
+{
   Value* a = this;
   if (a == b) {
     return true;
@@ -162,13 +175,13 @@ bool Value::hasBuddy(Context* c, Value* b) {
   }
   return false;
 }
-#endif // not NDEBUG
+#endif  // not NDEBUG
 
 Value* value(Context* c, ir::Type type, Site* site, Site* target)
 {
-  return new(c->zone) Value(site, target, type);
+  return new (c->zone) Value(site, target, type);
 }
 
-} // namespace regalloc
-} // namespace codegen
-} // namespace avian
+}  // namespace regalloc
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/compiler/value.h b/src/codegen/compiler/value.h
index 3eaed04fa7..9143a93a2b 100644
--- a/src/codegen/compiler/value.h
+++ b/src/codegen/compiler/value.h
@@ -62,8 +62,7 @@ class Value : public ir::Value {
 
 #ifndef NDEBUG
   bool hasBuddy(Context* c, Value* b);
-#endif // not NDEBUG
-
+#endif  // not NDEBUG
 };
 
 inline bool isFloatValue(ir::Value* a)
@@ -78,8 +77,8 @@ inline bool isGeneralValue(ir::Value* a)
 
 Value* value(Context* c, ir::Type type, Site* site = 0, Site* target = 0);
 
-} // namespace compiler
-} // namespace codegen
-} // namespace avian
+}  // namespace compiler
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_COMPILER_VALUE_H
+#endif  // AVIAN_CODEGEN_COMPILER_VALUE_H
diff --git a/src/codegen/registers.cpp b/src/codegen/registers.cpp
index 3bde6eb412..0f13f56244 100644
--- a/src/codegen/registers.cpp
+++ b/src/codegen/registers.cpp
@@ -13,23 +13,23 @@
 namespace avian {
 namespace codegen {
 
-unsigned
-RegisterMask::maskStart(uint32_t mask)
+unsigned RegisterMask::maskStart(uint32_t mask)
 {
   for (int i = 0; i <= 31; ++i) {
-    if (mask & (1 << i)) return i;
+    if (mask & (1 << i))
+      return i;
   }
   return 32;
 }
 
-unsigned
-RegisterMask::maskLimit(uint32_t mask)
+unsigned RegisterMask::maskLimit(uint32_t mask)
 {
   for (int i = 31; i >= 0; --i) {
-    if (mask & (1 << i)) return i + 1;
+    if (mask & (1 << i))
+      return i + 1;
   }
   return 0;
 }
 
-} // namespace codegen
-} // namespace avian
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/runtime.cpp b/src/codegen/runtime.cpp
index 6ae3a887a3..2c8ff51c15 100644
--- a/src/codegen/runtime.cpp
+++ b/src/codegen/runtime.cpp
@@ -277,6 +277,6 @@ uint64_t longToFloat(int64_t a)
   return vm::floatToBits(static_cast<float>(a));
 }
 
-} // namespace runtime
-} // namespace codegen
-} // namespace avian
+}  // namespace runtime
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/target/arm/assembler.cpp b/src/codegen/target/arm/assembler.cpp
index a7e678e39d..db396842a9 100644
--- a/src/codegen/target/arm/assembler.cpp
+++ b/src/codegen/target/arm/assembler.cpp
@@ -36,8 +36,9 @@ namespace arm {
 
 namespace isa {
 // HARDWARE FLAGS
-bool vfpSupported() {
-  // TODO: Use at runtime detection
+bool vfpSupported()
+{
+// TODO: Use at runtime detection
 #if defined(__ARM_PCS_VFP)
   // armhf
   return true;
@@ -49,9 +50,12 @@ bool vfpSupported() {
   return false;
 #endif
 }
-} // namespace isa
+}  // namespace isa
 
-inline unsigned lo8(int64_t i) { return (unsigned)(i&MASK_LO8); }
+inline unsigned lo8(int64_t i)
+{
+  return (unsigned)(i & MASK_LO8);
+}
 
 const RegisterFile MyRegisterFileWithoutFloats(GPR_MASK, 0);
 const RegisterFile MyRegisterFileWithFloats(GPR_MASK, FPR_MASK);
@@ -59,8 +63,8 @@ const RegisterFile MyRegisterFileWithFloats(GPR_MASK, FPR_MASK);
 const unsigned FrameHeaderSize = 1;
 
 const unsigned StackAlignmentInBytes = 8;
-const unsigned StackAlignmentInWords
-= StackAlignmentInBytes / TargetBytesPerWord;
+const unsigned StackAlignmentInWords = StackAlignmentInBytes
+                                       / TargetBytesPerWord;
 
 void resolve(MyBlock*);
 
@@ -74,16 +78,20 @@ using namespace isa;
 
 // END OPERATION COMPILERS
 
-unsigned
-argumentFootprint(unsigned footprint)
+unsigned argumentFootprint(unsigned footprint)
 {
   return max(pad(footprint, StackAlignmentInWords), StackAlignmentInWords);
 }
 
-void
-nextFrame(ArchitectureContext* con, uint32_t* start, unsigned size UNUSED,
-          unsigned footprint, void* link, bool,
-          int targetParameterFootprint UNUSED, void** ip, void** stack)
+void nextFrame(ArchitectureContext* con,
+               uint32_t* start,
+               unsigned size UNUSED,
+               unsigned footprint,
+               void* link,
+               bool,
+               int targetParameterFootprint UNUSED,
+               void** ip,
+               void** stack)
 {
   assertT(con, *ip >= start);
   assertT(con, *ip <= start + (size / TargetBytesPerWord));
@@ -108,7 +116,7 @@ nextFrame(ArchitectureContext* con, uint32_t* start, unsigned size UNUSED,
     return;
   }
 
-  if (*instruction == 0xe12fff1e) { // return
+  if (*instruction == 0xe12fff1e) {  // return
     *ip = link;
     return;
   }
@@ -116,7 +124,7 @@ nextFrame(ArchitectureContext* con, uint32_t* start, unsigned size UNUSED,
   if (TailCalls and targetParameterFootprint >= 0) {
     if (argumentFootprint(targetParameterFootprint) > StackAlignmentInWords) {
       offset += argumentFootprint(targetParameterFootprint)
-        - StackAlignmentInWords;
+                - StackAlignmentInWords;
     }
 
     // check for post-non-tail-call stack adjustment of the form "sub
@@ -125,9 +133,14 @@ nextFrame(ArchitectureContext* con, uint32_t* start, unsigned size UNUSED,
       unsigned value = *instruction & 0xff;
       unsigned rotation = (*instruction >> 8) & 0xf;
       switch (rotation) {
-      case  0: offset -= value / TargetBytesPerWord; break;
-      case 15: offset -= value; break;
-      default: abort(con);
+      case 0:
+        offset -= value / TargetBytesPerWord;
+        break;
+      case 15:
+        offset -= value;
+        break;
+      default:
+        abort(con);
       }
     }
 
@@ -138,45 +151,56 @@ nextFrame(ArchitectureContext* con, uint32_t* start, unsigned size UNUSED,
   *stack = static_cast<void**>(*stack) + offset;
 }
 
-class MyArchitecture: public Architecture {
+class MyArchitecture : public Architecture {
  public:
-  MyArchitecture(System* system): con(system), referenceCount(0) {
+  MyArchitecture(System* system) : con(system), referenceCount(0)
+  {
     populateTables(&con);
   }
 
-  virtual unsigned floatRegisterSize() {
+  virtual unsigned floatRegisterSize()
+  {
     return vfpSupported() ? 8 : 0;
   }
 
-  virtual const RegisterFile* registerFile() {
-    return vfpSupported() ? &MyRegisterFileWithFloats : &MyRegisterFileWithoutFloats;
+  virtual const RegisterFile* registerFile()
+  {
+    return vfpSupported() ? &MyRegisterFileWithFloats
+                          : &MyRegisterFileWithoutFloats;
   }
 
-  virtual int scratch() {
+  virtual int scratch()
+  {
     return 5;
   }
 
-  virtual int stack() {
+  virtual int stack()
+  {
     return StackRegister;
   }
 
-  virtual int thread() {
+  virtual int thread()
+  {
     return ThreadRegister;
   }
 
-  virtual int returnLow() {
+  virtual int returnLow()
+  {
     return 0;
   }
 
-  virtual int returnHigh() {
+  virtual int returnHigh()
+  {
     return 1;
   }
 
-  virtual int virtualCallTarget() {
+  virtual int virtualCallTarget()
+  {
     return 4;
   }
 
-  virtual int virtualCallIndex() {
+  virtual int virtualCallIndex()
+  {
     return 3;
   }
 
@@ -185,15 +209,18 @@ class MyArchitecture: public Architecture {
     return ir::TargetInfo(TargetBytesPerWord);
   }
 
-  virtual bool bigEndian() {
+  virtual bool bigEndian()
+  {
     return false;
   }
 
-  virtual uintptr_t maximumImmediateJump() {
+  virtual uintptr_t maximumImmediateJump()
+  {
     return 0x1FFFFFF;
   }
 
-  virtual bool reserved(int register_) {
+  virtual bool reserved(int register_)
+  {
     switch (register_) {
     case LinkRegister:
     case StackRegister:
@@ -206,15 +233,18 @@ class MyArchitecture: public Architecture {
     }
   }
 
-  virtual unsigned frameFootprint(unsigned footprint) {
+  virtual unsigned frameFootprint(unsigned footprint)
+  {
     return max(footprint, StackAlignmentInWords);
   }
 
-  virtual unsigned argumentFootprint(unsigned footprint) {
+  virtual unsigned argumentFootprint(unsigned footprint)
+  {
     return arm::argumentFootprint(footprint);
   }
 
-  virtual bool argumentAlignment() {
+  virtual bool argumentAlignment()
+  {
 #ifdef __APPLE__
     return false;
 #else
@@ -222,7 +252,8 @@ class MyArchitecture: public Architecture {
 #endif
   }
 
-  virtual bool argumentRegisterAlignment() {
+  virtual bool argumentRegisterAlignment()
+  {
 #ifdef __APPLE__
     return false;
 #else
@@ -230,30 +261,35 @@ class MyArchitecture: public Architecture {
 #endif
   }
 
-  virtual unsigned argumentRegisterCount() {
+  virtual unsigned argumentRegisterCount()
+  {
     return 4;
   }
 
-  virtual int argumentRegister(unsigned index) {
+  virtual int argumentRegister(unsigned index)
+  {
     assertT(&con, index < argumentRegisterCount());
 
     return index;
   }
 
-  virtual bool hasLinkRegister() {
+  virtual bool hasLinkRegister()
+  {
     return true;
   }
 
-  virtual unsigned stackAlignmentInWords() {
+  virtual unsigned stackAlignmentInWords()
+  {
     return StackAlignmentInWords;
   }
 
-  virtual bool matchCall(void* returnAddress, void* target) {
+  virtual bool matchCall(void* returnAddress, void* target)
+  {
     uint32_t* instruction = static_cast<uint32_t*>(returnAddress) - 1;
 
-    return *instruction == static_cast<uint32_t>
-      (bl(static_cast<uint8_t*>(target)
-          - reinterpret_cast<uint8_t*>(instruction)));
+    return *instruction == static_cast<uint32_t>(
+                               bl(static_cast<uint8_t*>(target)
+                                  - reinterpret_cast<uint8_t*>(instruction)));
   }
 
   virtual void updateCall(lir::UnaryOperation op UNUSED,
@@ -265,7 +301,8 @@ class MyArchitecture: public Architecture {
     case lir::Jump:
     case lir::AlignedCall:
     case lir::AlignedJump: {
-      updateOffset(con.s, static_cast<uint8_t*>(returnAddress) - 4,
+      updateOffset(con.s,
+                   static_cast<uint8_t*>(returnAddress) - 4,
                    reinterpret_cast<intptr_t>(newTarget));
     } break;
 
@@ -275,81 +312,105 @@ class MyArchitecture: public Architecture {
     case lir::AlignedLongJump: {
       uint32_t* p = static_cast<uint32_t*>(returnAddress) - 2;
       *reinterpret_cast<void**>(p + (((*p & PoolOffsetMask) + 8) / 4))
-        = newTarget;
+          = newTarget;
     } break;
 
-    default: abort(&con);
+    default:
+      abort(&con);
     }
   }
 
-  virtual unsigned constantCallSize() {
+  virtual unsigned constantCallSize()
+  {
     return 4;
   }
 
-  virtual void setConstant(void* dst, uint64_t constant) {
+  virtual void setConstant(void* dst, uint64_t constant)
+  {
     *static_cast<target_uintptr_t*>(dst) = constant;
   }
 
-  virtual unsigned alignFrameSize(unsigned sizeInWords) {
+  virtual unsigned alignFrameSize(unsigned sizeInWords)
+  {
     return pad(sizeInWords + FrameHeaderSize, StackAlignmentInWords)
-      - FrameHeaderSize;
+           - FrameHeaderSize;
   }
 
-  virtual void nextFrame(void* start, unsigned size, unsigned footprint,
-                         void* link, bool mostRecent,
-                         int targetParameterFootprint, void** ip,
+  virtual void nextFrame(void* start,
+                         unsigned size,
+                         unsigned footprint,
+                         void* link,
+                         bool mostRecent,
+                         int targetParameterFootprint,
+                         void** ip,
                          void** stack)
   {
-    arm::nextFrame(&con, static_cast<uint32_t*>(start), size, footprint, link,
-                mostRecent, targetParameterFootprint, ip, stack);
+    arm::nextFrame(&con,
+                   static_cast<uint32_t*>(start),
+                   size,
+                   footprint,
+                   link,
+                   mostRecent,
+                   targetParameterFootprint,
+                   ip,
+                   stack);
   }
 
-  virtual void* frameIp(void* stack) {
+  virtual void* frameIp(void* stack)
+  {
     return stack ? static_cast<void**>(stack)[returnAddressOffset()] : 0;
   }
 
-  virtual unsigned frameHeaderSize() {
+  virtual unsigned frameHeaderSize()
+  {
     return FrameHeaderSize;
   }
 
-  virtual unsigned frameReturnAddressSize() {
+  virtual unsigned frameReturnAddressSize()
+  {
     return 0;
   }
 
-  virtual unsigned frameFooterSize() {
+  virtual unsigned frameFooterSize()
+  {
     return 0;
   }
 
-  virtual int returnAddressOffset() {
+  virtual int returnAddressOffset()
+  {
     return -1;
   }
 
-  virtual int framePointerOffset() {
+  virtual int framePointerOffset()
+  {
     return 0;
   }
-  
-  virtual bool alwaysCondensed(lir::BinaryOperation) {
+
+  virtual bool alwaysCondensed(lir::BinaryOperation)
+  {
     return false;
   }
-  
-  virtual bool alwaysCondensed(lir::TernaryOperation) {
+
+  virtual bool alwaysCondensed(lir::TernaryOperation)
+  {
     return false;
   }
-  
-  virtual void plan
-  (lir::UnaryOperation,
-   unsigned, OperandMask& aMask,
-   bool* thunk)
+
+  virtual void plan(lir::UnaryOperation,
+                    unsigned,
+                    OperandMask& aMask,
+                    bool* thunk)
   {
     aMask.typeMask = (1 << lir::RegisterOperand) | (1 << lir::ConstantOperand);
     aMask.registerMask = ~static_cast<uint64_t>(0);
     *thunk = false;
   }
 
-  virtual void planSource
-  (lir::BinaryOperation op,
-   unsigned aSize, OperandMask& aMask,
-   unsigned bSize, bool* thunk)
+  virtual void planSource(lir::BinaryOperation op,
+                          unsigned aSize,
+                          OperandMask& aMask,
+                          unsigned bSize,
+                          bool* thunk)
   {
     *thunk = false;
     aMask.typeMask = ~0;
@@ -403,11 +464,12 @@ class MyArchitecture: public Architecture {
       break;
     }
   }
-  
-  virtual void planDestination
-  (lir::BinaryOperation op,
-   unsigned, const OperandMask& aMask,
-   unsigned, OperandMask& bMask)
+
+  virtual void planDestination(lir::BinaryOperation op,
+                               unsigned,
+                               const OperandMask& aMask,
+                               unsigned,
+                               OperandMask& bMask)
   {
     bMask.typeMask = (1 << lir::RegisterOperand) | (1 << lir::MemoryOperand);
     bMask.registerMask = GPR_MASK64;
@@ -443,10 +505,10 @@ class MyArchitecture: public Architecture {
     }
   }
 
-  virtual void planMove
-  (unsigned, OperandMask& srcMask,
-   OperandMask& tmpMask,
-   const OperandMask& dstMask)
+  virtual void planMove(unsigned,
+                        OperandMask& srcMask,
+                        OperandMask& tmpMask,
+                        const OperandMask& dstMask)
   {
     srcMask.typeMask = ~0;
     srcMask.registerMask = ~static_cast<uint64_t>(0);
@@ -459,20 +521,21 @@ class MyArchitecture: public Architecture {
       srcMask.typeMask = 1 << lir::RegisterOperand;
       tmpMask.typeMask = 1 << lir::RegisterOperand;
       tmpMask.registerMask = GPR_MASK64;
-    } else if (vfpSupported() &&
-               dstMask.typeMask & 1 << lir::RegisterOperand &&
-               dstMask.registerMask & FPR_MASK) {
-      srcMask.typeMask = tmpMask.typeMask = 1 << lir::RegisterOperand |
-                                    1 << lir::MemoryOperand;
+    } else if (vfpSupported() && dstMask.typeMask & 1 << lir::RegisterOperand
+               && dstMask.registerMask & FPR_MASK) {
+      srcMask.typeMask = tmpMask.typeMask = 1 << lir::RegisterOperand
+                                            | 1 << lir::MemoryOperand;
       tmpMask.registerMask = ~static_cast<uint64_t>(0);
     }
   }
 
-  virtual void planSource
-  (lir::TernaryOperation op,
-   unsigned, OperandMask& aMask,
-   unsigned bSize, OperandMask& bMask,
-   unsigned, bool* thunk)
+  virtual void planSource(lir::TernaryOperation op,
+                          unsigned,
+                          OperandMask& aMask,
+                          unsigned bSize,
+                          OperandMask& bMask,
+                          unsigned,
+                          bool* thunk)
   {
     aMask.typeMask = (1 << lir::RegisterOperand) | (1 << lir::ConstantOperand);
     aMask.registerMask = GPR_MASK64;
@@ -486,7 +549,8 @@ class MyArchitecture: public Architecture {
     case lir::ShiftLeft:
     case lir::ShiftRight:
     case lir::UnsignedShiftRight:
-      if (bSize == 8) aMask.typeMask = bMask.typeMask = (1 << lir::RegisterOperand);
+      if (bSize == 8)
+        aMask.typeMask = bMask.typeMask = (1 << lir::RegisterOperand);
       break;
 
     case lir::Add:
@@ -512,7 +576,7 @@ class MyArchitecture: public Architecture {
         aMask.registerMask = bMask.registerMask = FPR_MASK64;
       } else {
         *thunk = true;
-      }    
+      }
       break;
 
     case lir::JumpIfFloatEqual:
@@ -538,11 +602,13 @@ class MyArchitecture: public Architecture {
     }
   }
 
-  virtual void planDestination
-  (lir::TernaryOperation op,
-   unsigned, const OperandMask& aMask UNUSED,
-   unsigned, const OperandMask& bMask,
-   unsigned, OperandMask& cMask)
+  virtual void planDestination(lir::TernaryOperation op,
+                               unsigned,
+                               const OperandMask& aMask UNUSED,
+                               unsigned,
+                               const OperandMask& bMask,
+                               unsigned,
+                               OperandMask& cMask)
   {
     if (isBranch(op)) {
       cMask.typeMask = (1 << lir::ConstantOperand);
@@ -555,12 +621,14 @@ class MyArchitecture: public Architecture {
 
   virtual Assembler* makeAssembler(Allocator* allocator, Zone* zone);
 
-  virtual void acquire() {
-    ++ referenceCount;
+  virtual void acquire()
+  {
+    ++referenceCount;
   }
 
-  virtual void release() {
-    if (-- referenceCount == 0) {
+  virtual void release()
+  {
+    if (--referenceCount == 0) {
       con.s->free(this);
     }
   }
@@ -569,18 +637,21 @@ class MyArchitecture: public Architecture {
   unsigned referenceCount;
 };
 
-class MyAssembler: public Assembler {
+class MyAssembler : public Assembler {
  public:
-  MyAssembler(System* s, Allocator* a, Zone* zone, MyArchitecture* arch):
-    con(s, a, zone), arch_(arch)
-  { }
+  MyAssembler(System* s, Allocator* a, Zone* zone, MyArchitecture* arch)
+      : con(s, a, zone), arch_(arch)
+  {
+  }
 
-  virtual void setClient(Client* client) {
+  virtual void setClient(Client* client)
+  {
     assertT(&con, con.client == 0);
     con.client = client;
   }
 
-  virtual Architecture* arch() {
+  virtual Architecture* arch()
+  {
     return arch_;
   }
 
@@ -589,12 +660,17 @@ class MyAssembler: public Assembler {
   {
     lir::Register stack(StackRegister);
     lir::Memory stackLimit(ThreadRegister, stackLimitOffsetFromThread);
-    lir::Constant handlerConstant(new(con.zone) ResolvedPromise(handler));
-    branchRM(&con, lir::JumpIfGreaterOrEqual, TargetBytesPerWord, &stack, &stackLimit,
+    lir::Constant handlerConstant(new (con.zone) ResolvedPromise(handler));
+    branchRM(&con,
+             lir::JumpIfGreaterOrEqual,
+             TargetBytesPerWord,
+             &stack,
+             &stackLimit,
              &handlerConstant);
   }
 
-  virtual void saveFrame(unsigned stackOffset, unsigned ipOffset) {
+  virtual void saveFrame(unsigned stackOffset, unsigned ipOffset)
+  {
     lir::Register link(LinkRegister);
     lir::Memory linkDst(ThreadRegister, ipOffset);
     moveRM(&con, TargetBytesPerWord, &link, TargetBytesPerWord, &linkDst);
@@ -604,7 +680,8 @@ class MyAssembler: public Assembler {
     moveRM(&con, TargetBytesPerWord, &stack, TargetBytesPerWord, &stackDst);
   }
 
-  virtual void pushFrame(unsigned argumentCount, ...) {
+  virtual void pushFrame(unsigned argumentCount, ...)
+  {
     struct Argument {
       unsigned size;
       lir::OperandType type;
@@ -612,49 +689,57 @@ class MyAssembler: public Assembler {
     };
     RUNTIME_ARRAY(Argument, arguments, argumentCount);
 
-    va_list a; va_start(a, argumentCount);
+    va_list a;
+    va_start(a, argumentCount);
     unsigned footprint = 0;
     for (unsigned i = 0; i < argumentCount; ++i) {
       RUNTIME_ARRAY_BODY(arguments)[i].size = va_arg(a, unsigned);
-      RUNTIME_ARRAY_BODY(arguments)[i].type = static_cast<lir::OperandType>(va_arg(a, int));
+      RUNTIME_ARRAY_BODY(arguments)[i].type
+          = static_cast<lir::OperandType>(va_arg(a, int));
       RUNTIME_ARRAY_BODY(arguments)[i].operand = va_arg(a, lir::Operand*);
-      footprint += ceilingDivide(RUNTIME_ARRAY_BODY(arguments)[i].size, TargetBytesPerWord);
+      footprint += ceilingDivide(RUNTIME_ARRAY_BODY(arguments)[i].size,
+                                 TargetBytesPerWord);
     }
     va_end(a);
 
     allocateFrame(arch_->alignFrameSize(footprint));
-    
+
     unsigned offset = 0;
     for (unsigned i = 0; i < argumentCount; ++i) {
       if (i < arch_->argumentRegisterCount()) {
         lir::Register dst(arch_->argumentRegister(i));
 
         apply(lir::Move,
-              OperandInfo(
-                RUNTIME_ARRAY_BODY(arguments)[i].size,
-                RUNTIME_ARRAY_BODY(arguments)[i].type,
-                RUNTIME_ARRAY_BODY(arguments)[i].operand),
-              OperandInfo(
-                pad(RUNTIME_ARRAY_BODY(arguments)[i].size, TargetBytesPerWord), lir::RegisterOperand, &dst));
+              OperandInfo(RUNTIME_ARRAY_BODY(arguments)[i].size,
+                          RUNTIME_ARRAY_BODY(arguments)[i].type,
+                          RUNTIME_ARRAY_BODY(arguments)[i].operand),
+              OperandInfo(pad(RUNTIME_ARRAY_BODY(arguments)[i].size,
+                              TargetBytesPerWord),
+                          lir::RegisterOperand,
+                          &dst));
 
-        offset += ceilingDivide(RUNTIME_ARRAY_BODY(arguments)[i].size, TargetBytesPerWord);
+        offset += ceilingDivide(RUNTIME_ARRAY_BODY(arguments)[i].size,
+                                TargetBytesPerWord);
       } else {
         lir::Memory dst(StackRegister, offset * TargetBytesPerWord);
 
         apply(lir::Move,
-              OperandInfo(
-                RUNTIME_ARRAY_BODY(arguments)[i].size,
-                RUNTIME_ARRAY_BODY(arguments)[i].type,
-                RUNTIME_ARRAY_BODY(arguments)[i].operand),
-              OperandInfo(
-                pad(RUNTIME_ARRAY_BODY(arguments)[i].size, TargetBytesPerWord), lir::MemoryOperand, &dst));
+              OperandInfo(RUNTIME_ARRAY_BODY(arguments)[i].size,
+                          RUNTIME_ARRAY_BODY(arguments)[i].type,
+                          RUNTIME_ARRAY_BODY(arguments)[i].operand),
+              OperandInfo(pad(RUNTIME_ARRAY_BODY(arguments)[i].size,
+                              TargetBytesPerWord),
+                          lir::MemoryOperand,
+                          &dst));
 
-        offset += ceilingDivide(RUNTIME_ARRAY_BODY(arguments)[i].size, TargetBytesPerWord);
+        offset += ceilingDivide(RUNTIME_ARRAY_BODY(arguments)[i].size,
+                                TargetBytesPerWord);
       }
     }
   }
 
-  virtual void allocateFrame(unsigned footprint) {
+  virtual void allocateFrame(unsigned footprint)
+  {
     footprint += FrameHeaderSize;
 
     // larger frames may require multiple subtract/add instructions
@@ -668,28 +753,36 @@ class MyAssembler: public Assembler {
     subC(&con, TargetBytesPerWord, &footprintConstant, &stack, &stack);
 
     lir::Register returnAddress(LinkRegister);
-    lir::Memory returnAddressDst
-      (StackRegister, (footprint - 1) * TargetBytesPerWord);
-    moveRM(&con, TargetBytesPerWord, &returnAddress, TargetBytesPerWord,
+    lir::Memory returnAddressDst(StackRegister,
+                                 (footprint - 1) * TargetBytesPerWord);
+    moveRM(&con,
+           TargetBytesPerWord,
+           &returnAddress,
+           TargetBytesPerWord,
            &returnAddressDst);
   }
 
-  virtual void adjustFrame(unsigned difference) {
+  virtual void adjustFrame(unsigned difference)
+  {
     lir::Register stack(StackRegister);
     ResolvedPromise differencePromise(difference * TargetBytesPerWord);
     lir::Constant differenceConstant(&differencePromise);
     subC(&con, TargetBytesPerWord, &differenceConstant, &stack, &stack);
   }
 
-  virtual void popFrame(unsigned footprint) {
+  virtual void popFrame(unsigned footprint)
+  {
     footprint += FrameHeaderSize;
 
     lir::Register returnAddress(LinkRegister);
-    lir::Memory returnAddressSrc
-      (StackRegister, (footprint - 1) * TargetBytesPerWord);
-    moveMR(&con, TargetBytesPerWord, &returnAddressSrc, TargetBytesPerWord,
+    lir::Memory returnAddressSrc(StackRegister,
+                                 (footprint - 1) * TargetBytesPerWord);
+    moveMR(&con,
+           TargetBytesPerWord,
+           &returnAddressSrc,
+           TargetBytesPerWord,
            &returnAddress);
-    
+
     lir::Register stack(StackRegister);
     ResolvedPromise footprintPromise(footprint * TargetBytesPerWord);
     lir::Constant footprintConstant(&footprintPromise);
@@ -708,14 +801,17 @@ class MyAssembler: public Assembler {
         footprint += FrameHeaderSize;
 
         lir::Register link(LinkRegister);
-        lir::Memory returnAddressSrc
-          (StackRegister, (footprint - 1) * TargetBytesPerWord);
-        moveMR(&con, TargetBytesPerWord, &returnAddressSrc, TargetBytesPerWord,
+        lir::Memory returnAddressSrc(StackRegister,
+                                     (footprint - 1) * TargetBytesPerWord);
+        moveMR(&con,
+               TargetBytesPerWord,
+               &returnAddressSrc,
+               TargetBytesPerWord,
                &link);
-    
+
         lir::Register stack(StackRegister);
-        ResolvedPromise footprintPromise
-          ((footprint - offset) * TargetBytesPerWord);
+        ResolvedPromise footprintPromise((footprint - offset)
+                                         * TargetBytesPerWord);
         lir::Constant footprintConstant(&footprintPromise);
         addC(&con, TargetBytesPerWord, &footprintConstant, &stack, &stack);
 
@@ -769,46 +865,52 @@ class MyAssembler: public Assembler {
     return_(&con);
   }
 
-  virtual void apply(lir::Operation op) {
+  virtual void apply(lir::Operation op)
+  {
     arch_->con.operations[op](&con);
   }
 
   virtual void apply(lir::UnaryOperation op, OperandInfo a)
   {
-    arch_->con.unaryOperations[Multimethod::index(op, a.type)]
-      (&con, a.size, a.operand);
+    arch_->con.unaryOperations[Multimethod::index(op, a.type)](
+        &con, a.size, a.operand);
   }
 
   virtual void apply(lir::BinaryOperation op, OperandInfo a, OperandInfo b)
   {
-    arch_->con.binaryOperations[index(&(arch_->con), op, a.type, b.type)]
-      (&con, a.size, a.operand, b.size, b.operand);
+    arch_->con.binaryOperations[index(&(arch_->con), op, a.type, b.type)](
+        &con, a.size, a.operand, b.size, b.operand);
   }
 
-  virtual void apply(lir::TernaryOperation op, OperandInfo a, OperandInfo b, OperandInfo c)
+  virtual void apply(lir::TernaryOperation op,
+                     OperandInfo a,
+                     OperandInfo b,
+                     OperandInfo c)
   {
     if (isBranch(op)) {
       assertT(&con, a.size == b.size);
       assertT(&con, c.size == TargetBytesPerWord);
       assertT(&con, c.type == lir::ConstantOperand);
 
-      arch_->con.branchOperations[branchIndex(&(arch_->con), a.type, b.type)]
-        (&con, op, a.size, a.operand, b.operand, c.operand);
+      arch_->con.branchOperations[branchIndex(&(arch_->con), a.type, b.type)](
+          &con, op, a.size, a.operand, b.operand, c.operand);
     } else {
       assertT(&con, b.size == c.size);
       assertT(&con, b.type == lir::RegisterOperand);
       assertT(&con, c.type == lir::RegisterOperand);
 
-      arch_->con.ternaryOperations[index(&(arch_->con), op, a.type)]
-        (&con, b.size, a.operand, b.operand, c.operand);
+      arch_->con.ternaryOperations[index(&(arch_->con), op, a.type)](
+          &con, b.size, a.operand, b.operand, c.operand);
     }
   }
 
-  virtual void setDestination(uint8_t* dst) {
+  virtual void setDestination(uint8_t* dst)
+  {
     con.result = dst;
   }
 
-  virtual void write() {
+  virtual void write()
+  {
     uint8_t* dst = con.result;
     unsigned dstOffset = 0;
     for (MyBlock* b = con.firstBlock; b; b = b->next) {
@@ -828,8 +930,11 @@ class MyAssembler: public Assembler {
         unsigned poolSize = 0;
         for (PoolOffset* o = e->poolOffsetHead; o; o = o->next) {
           if (DebugPool) {
-            fprintf(stderr, "visit pool offset %p %d in block %p\n",
-                    o, o->offset, b);
+            fprintf(stderr,
+                    "visit pool offset %p %d in block %p\n",
+                    o,
+                    o->offset,
+                    b);
           }
 
           unsigned entry = dstOffset + poolSize;
@@ -840,8 +945,8 @@ class MyAssembler: public Assembler {
 
           o->entry->address = dst + entry;
 
-          unsigned instruction = o->block->start
-            + padding(o->block, o->offset) + o->offset;
+          unsigned instruction = o->block->start + padding(o->block, o->offset)
+                                 + o->offset;
 
           int32_t v = (entry - 8) - instruction;
           expect(&con, v == (v & PoolOffsetMask));
@@ -854,8 +959,8 @@ class MyAssembler: public Assembler {
 
         bool jump = needJump(b);
         if (jump) {
-          write4
-            (dst + dstOffset, isa::b((poolSize + TargetBytesPerWord - 8) >> 2));
+          write4(dst + dstOffset,
+                 isa::b((poolSize + TargetBytesPerWord - 8) >> 2));
         }
 
         dstOffset += poolSize + (jump ? TargetBytesPerWord : 0);
@@ -879,20 +984,23 @@ class MyAssembler: public Assembler {
         *static_cast<target_uintptr_t*>(e->address) = e->constant->value();
       } else {
         new (e->constant->listen(sizeof(ConstantPoolListener)))
-          ConstantPoolListener(con.s, static_cast<target_uintptr_t*>(e->address),
-                               e->callOffset
-                               ? dst + e->callOffset->value() + 8
-                               : 0);
+            ConstantPoolListener(
+                con.s,
+                static_cast<target_uintptr_t*>(e->address),
+                e->callOffset ? dst + e->callOffset->value() + 8 : 0);
       }
-//       fprintf(stderr, "constant %p at %p\n", reinterpret_cast<void*>(e->constant->value()), e->address);
+      //       fprintf(stderr, "constant %p at %p\n",
+      //       reinterpret_cast<void*>(e->constant->value()), e->address);
     }
   }
 
-  virtual Promise* offset(bool forTrace) {
+  virtual Promise* offset(bool forTrace)
+  {
     return arm::offsetPromise(&con, forTrace);
   }
 
-  virtual Block* endBlock(bool startNew) {
+  virtual Block* endBlock(bool startNew)
+  {
     MyBlock* b = con.lastBlock;
     b->size = con.code.length() - b->offset;
     if (startNew) {
@@ -903,26 +1011,33 @@ class MyAssembler: public Assembler {
     return b;
   }
 
-  virtual void endEvent() {
+  virtual void endEvent()
+  {
     MyBlock* b = con.lastBlock;
     unsigned thisEventOffset = con.code.length() - b->offset;
     if (b->poolOffsetHead) {
       int32_t v = (thisEventOffset + TargetBytesPerWord - 8)
-        - b->poolOffsetHead->offset;
+                  - b->poolOffsetHead->offset;
 
       if (v > 0 and v != (v & PoolOffsetMask)) {
-        appendPoolEvent
-          (&con, b, b->lastEventOffset, b->poolOffsetHead,
-           b->lastPoolOffsetTail);
+        appendPoolEvent(&con,
+                        b,
+                        b->lastEventOffset,
+                        b->poolOffsetHead,
+                        b->lastPoolOffsetTail);
 
         if (DebugPool) {
           for (PoolOffset* o = b->poolOffsetHead;
-               o != b->lastPoolOffsetTail->next; o = o->next)
-          {
+               o != b->lastPoolOffsetTail->next;
+               o = o->next) {
             fprintf(stderr,
                     "in endEvent, include %p %d in pool event %p at offset %d "
                     "in block %p\n",
-                    o, o->offset, b->poolEventTail, b->lastEventOffset, b);
+                    o,
+                    o->offset,
+                    b->poolEventTail,
+                    b->lastEventOffset,
+                    b);
           }
         }
 
@@ -937,15 +1052,18 @@ class MyAssembler: public Assembler {
     b->lastPoolOffsetTail = b->poolOffsetTail;
   }
 
-  virtual unsigned length() {
+  virtual unsigned length()
+  {
     return con.code.length();
   }
 
-  virtual unsigned footerSize() {
+  virtual unsigned footerSize()
+  {
     return 0;
   }
 
-  virtual void dispose() {
+  virtual void dispose()
+  {
     con.code.dispose();
   }
 
@@ -953,17 +1071,18 @@ class MyAssembler: public Assembler {
   MyArchitecture* arch_;
 };
 
-Assembler* MyArchitecture::makeAssembler(Allocator* allocator, Zone* zone) {
-  return new(zone) MyAssembler(this->con.s, allocator, zone, this);
-}
-
-} // namespace arm
-
-Architecture*
-makeArchitectureArm(System* system, bool)
+Assembler* MyArchitecture::makeAssembler(Allocator* allocator, Zone* zone)
 {
-  return new (allocate(system, sizeof(arm::MyArchitecture))) arm::MyArchitecture(system);
+  return new (zone) MyAssembler(this->con.s, allocator, zone, this);
 }
 
-} // namespace codegen
-} // namespace avian
+}  // namespace arm
+
+Architecture* makeArchitectureArm(System* system, bool)
+{
+  return new (allocate(system, sizeof(arm::MyArchitecture)))
+      arm::MyArchitecture(system);
+}
+
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/target/arm/block.cpp b/src/codegen/target/arm/block.cpp
index f6383965ea..d0995e329b 100644
--- a/src/codegen/target/arm/block.cpp
+++ b/src/codegen/target/arm/block.cpp
@@ -19,13 +19,23 @@ void resolve(MyBlock*);
 
 unsigned padding(MyBlock*, unsigned);
 
-MyBlock::MyBlock(Context* context, unsigned offset):
-  context(context), next(0), poolOffsetHead(0), poolOffsetTail(0),
-  lastPoolOffsetTail(0), poolEventHead(0), poolEventTail(0),
-  lastEventOffset(0), offset(offset), start(~0), size(0)
-{ }
+MyBlock::MyBlock(Context* context, unsigned offset)
+    : context(context),
+      next(0),
+      poolOffsetHead(0),
+      poolOffsetTail(0),
+      lastPoolOffsetTail(0),
+      poolEventHead(0),
+      poolEventTail(0),
+      lastEventOffset(0),
+      offset(offset),
+      start(~0),
+      size(0)
+{
+}
 
-unsigned MyBlock::resolve(unsigned start, Assembler::Block* next) {
+unsigned MyBlock::resolve(unsigned start, Assembler::Block* next)
+{
   this->start = start;
   this->next = static_cast<MyBlock*>(next);
 
@@ -34,6 +44,6 @@ unsigned MyBlock::resolve(unsigned start, Assembler::Block* next) {
   return start + size + padding(this, size);
 }
 
-} // namespace arm
-} // namespace codegen
-} // namespace avian
+}  // namespace arm
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/target/arm/block.h b/src/codegen/target/arm/block.h
index b926924969..d40cc45d3d 100644
--- a/src/codegen/target/arm/block.h
+++ b/src/codegen/target/arm/block.h
@@ -20,7 +20,7 @@ namespace arm {
 
 class PoolEvent;
 
-class MyBlock: public Assembler::Block {
+class MyBlock : public Assembler::Block {
  public:
   MyBlock(Context* context, unsigned offset);
 
@@ -39,8 +39,8 @@ class MyBlock: public Assembler::Block {
   unsigned size;
 };
 
-} // namespace arm
-} // namespace codegen
-} // namespace avian
+}  // namespace arm
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_ASSEMBLER_ARM_BLOCK_H
+#endif  // AVIAN_CODEGEN_ASSEMBLER_ARM_BLOCK_H
diff --git a/src/codegen/target/arm/context.cpp b/src/codegen/target/arm/context.cpp
index d1f64e7916..1c2757abbc 100644
--- a/src/codegen/target/arm/context.cpp
+++ b/src/codegen/target/arm/context.cpp
@@ -31,6 +31,6 @@ Context::Context(vm::System* s, util::Allocator* a, vm::Zone* zone)
 {
 }
 
-} // namespace arm
-} // namespace codegen
-} // namespace avian
+}  // namespace arm
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/target/arm/context.h b/src/codegen/target/arm/context.h
index 4bf8c5adb2..15d3c2e0f0 100644
--- a/src/codegen/target/arm/context.h
+++ b/src/codegen/target/arm/context.h
@@ -18,14 +18,14 @@
 namespace vm {
 class System;
 class Zone;
-} // namespace vm
+}  // namespace vm
 
 namespace avian {
 
 namespace util {
 class Aborter;
 class Allocator;
-} // namespace util
+}  // namespace util
 
 namespace codegen {
 namespace arm {
@@ -57,43 +57,57 @@ typedef void (*OperationType)(Context*);
 
 typedef void (*UnaryOperationType)(Context*, unsigned, lir::Operand*);
 
-typedef void (*BinaryOperationType)
-(Context*, unsigned, lir::Operand*, unsigned, lir::Operand*);
+typedef void (*BinaryOperationType)(Context*,
+                                    unsigned,
+                                    lir::Operand*,
+                                    unsigned,
+                                    lir::Operand*);
 
-typedef void (*TernaryOperationType)
-(Context*, unsigned, lir::Operand*, lir::Operand*,
- lir::Operand*);
+typedef void (*TernaryOperationType)(Context*,
+                                     unsigned,
+                                     lir::Operand*,
+                                     lir::Operand*,
+                                     lir::Operand*);
 
-typedef void (*BranchOperationType)
-(Context*, lir::TernaryOperation, unsigned, lir::Operand*,
- lir::Operand*, lir::Operand*);
+typedef void (*BranchOperationType)(Context*,
+                                    lir::TernaryOperation,
+                                    unsigned,
+                                    lir::Operand*,
+                                    lir::Operand*,
+                                    lir::Operand*);
 
 class ArchitectureContext {
  public:
-  ArchitectureContext(vm::System* s): s(s) { }
+  ArchitectureContext(vm::System* s) : s(s)
+  {
+  }
 
   vm::System* s;
   OperationType operations[lir::OperationCount];
-  UnaryOperationType unaryOperations[lir::UnaryOperationCount
-                                     * lir::OperandTypeCount];
-  BinaryOperationType binaryOperations
-  [lir::BinaryOperationCount * lir::OperandTypeCount * lir::OperandTypeCount];
-  TernaryOperationType ternaryOperations
-  [lir::NonBranchTernaryOperationCount * lir::OperandTypeCount];
-  BranchOperationType branchOperations
-  [lir::BranchOperationCount * lir::OperandTypeCount * lir::OperandTypeCount];
+  UnaryOperationType
+      unaryOperations[lir::UnaryOperationCount * lir::OperandTypeCount];
+  BinaryOperationType binaryOperations[lir::BinaryOperationCount
+                                       * lir::OperandTypeCount
+                                       * lir::OperandTypeCount];
+  TernaryOperationType ternaryOperations[lir::NonBranchTernaryOperationCount
+                                         * lir::OperandTypeCount];
+  BranchOperationType branchOperations[lir::BranchOperationCount
+                                       * lir::OperandTypeCount
+                                       * lir::OperandTypeCount];
 };
 
-inline avian::util::Aborter* getAborter(Context* c) {
+inline avian::util::Aborter* getAborter(Context* c)
+{
   return c->s;
 }
 
-inline avian::util::Aborter* getAborter(ArchitectureContext* c) {
+inline avian::util::Aborter* getAborter(ArchitectureContext* c)
+{
   return c->s;
 }
 
-} // namespace arm
-} // namespace codegen
-} // namespace avian
+}  // namespace arm
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_ASSEMBLER_ARM_CONTEXT_H
+#endif  // AVIAN_CODEGEN_ASSEMBLER_ARM_CONTEXT_H
diff --git a/src/codegen/target/arm/encode.h b/src/codegen/target/arm/encode.h
index aef77ca50e..edbeb3d071 100644
--- a/src/codegen/target/arm/encode.h
+++ b/src/codegen/target/arm/encode.h
@@ -25,162 +25,668 @@ const int FPSID = 0x0;
 const int FPSCR = 0x1;
 const int FPEXC = 0x8;
 // INSTRUCTION OPTIONS
-enum CONDITION { EQ, NE, CS, CC, MI, PL, VS, VC, HI, LS, GE, LT, GT, LE, AL, NV };
+enum CONDITION {
+  EQ,
+  NE,
+  CS,
+  CC,
+  MI,
+  PL,
+  VS,
+  VC,
+  HI,
+  LS,
+  GE,
+  LT,
+  GT,
+  LE,
+  AL,
+  NV
+};
 enum SHIFTOP { LSL, LSR, ASR, ROR };
 // INSTRUCTION FORMATS
-inline int DATA(int cond, int opcode, int S, int Rn, int Rd, int shift, int Sh, int Rm)
-{ return cond<<28 | opcode<<21 | S<<20 | Rn<<16 | Rd<<12 | shift<<7 | Sh<<5 | Rm; }
-inline int DATAS(int cond, int opcode, int S, int Rn, int Rd, int Rs, int Sh, int Rm)
-{ return cond<<28 | opcode<<21 | S<<20 | Rn<<16 | Rd<<12 | Rs<<8 | Sh<<5 | 1<<4 | Rm; }
+inline int
+    DATA(int cond, int opcode, int S, int Rn, int Rd, int shift, int Sh, int Rm)
+{
+  return cond << 28 | opcode << 21 | S << 20 | Rn << 16 | Rd << 12 | shift << 7
+         | Sh << 5 | Rm;
+}
+inline int
+    DATAS(int cond, int opcode, int S, int Rn, int Rd, int Rs, int Sh, int Rm)
+{
+  return cond << 28 | opcode << 21 | S << 20 | Rn << 16 | Rd << 12 | Rs << 8
+         | Sh << 5 | 1 << 4 | Rm;
+}
 inline int DATAI(int cond, int opcode, int S, int Rn, int Rd, int rot, int imm)
-{ return cond<<28 | 1<<25 | opcode<<21 | S<<20 | Rn<<16 | Rd<<12 | rot<<8 | (imm&0xff); }
+{
+  return cond << 28 | 1 << 25 | opcode << 21 | S << 20 | Rn << 16 | Rd << 12
+         | rot << 8 | (imm & 0xff);
+}
 inline int BRANCH(int cond, int L, int offset)
-{ return cond<<28 | 5<<25 | L<<24 | (offset&0xffffff); }
+{
+  return cond << 28 | 5 << 25 | L << 24 | (offset & 0xffffff);
+}
 inline int BRANCHX(int cond, int L, int Rm)
-{ return cond<<28 | 0x4bffc<<6 | L<<5 | 1<<4 | Rm; }
+{
+  return cond << 28 | 0x4bffc << 6 | L << 5 | 1 << 4 | Rm;
+}
 inline int MULTIPLY(int cond, int mul, int S, int Rd, int Rn, int Rs, int Rm)
-{ return cond<<28 | mul<<21 | S<<20 | Rd<<16 | Rn<<12 | Rs<<8 | 9<<4 | Rm; }
-inline int XFER(int cond, int P, int U, int B, int W, int L, int Rn, int Rd, int shift, int Sh, int Rm)
-{ return cond<<28 | 3<<25 | P<<24 | U<<23 | B<<22 | W<<21 | L<<20 | Rn<<16 | Rd<<12 | shift<<7 | Sh<<5 | Rm; }
-inline int XFERI(int cond, int P, int U, int B, int W, int L, int Rn, int Rd, int offset)
-{ return cond<<28 | 2<<25 | P<<24 | U<<23 | B<<22 | W<<21 | L<<20 | Rn<<16 | Rd<<12 | (offset&0xfff); }
-inline int XFER2(int cond, int P, int U, int W, int L, int Rn, int Rd, int S, int H, int Rm)
-{ return cond<<28 | P<<24 | U<<23 | W<<21 | L<<20 | Rn<<16 | Rd<<12 | 1<<7 | S<<6 | H<<5 | 1<<4 | Rm; }
-inline int XFER2I(int cond, int P, int U, int W, int L, int Rn, int Rd, int offsetH, int S, int H, int offsetL)
-{ return cond<<28 | P<<24 | U<<23 | 1<<22 | W<<21 | L<<20 | Rn<<16 | Rd<<12 | offsetH<<8 | 1<<7 | S<<6 | H<<5 | 1<<4 | (offsetL&0xf); }
-inline int COOP(int cond, int opcode_1, int CRn, int CRd, int cp_num, int opcode_2, int CRm)
-{ return cond<<28 | 0xe<<24 | opcode_1<<20 | CRn<<16 | CRd<<12 | cp_num<<8 | opcode_2<<5 | CRm; }
-inline int COXFER(int cond, int P, int U, int N, int W, int L, int Rn, int CRd, int cp_num, int offset) // offset is in words, not bytes
-{ return cond<<28 | 0x6<<25 | P<<24 | U<<23 | N<<22 | W<<21 | L<<20 | Rn<<16 | CRd<<12 | cp_num<<8 | (offset&0xff)>>2; }
-inline int COREG(int cond, int opcode_1, int L, int CRn, int Rd, int cp_num, int opcode_2, int CRm)
-{ return cond<<28 | 0xe<<24 | opcode_1<<21 | L<<20 | CRn<<16 | Rd<<12 | cp_num<<8 | opcode_2<<5 | 1<<4 | CRm; }
-inline int COREG2(int cond, int L, int Rn, int Rd, int cp_num, int opcode, int CRm)
-{ return cond<<28 | 0xc4<<20 | L<<20 | Rn<<16 | Rd<<12 | cp_num<<8 | opcode<<4 | CRm;}
+{
+  return cond << 28 | mul << 21 | S << 20 | Rd << 16 | Rn << 12 | Rs << 8
+         | 9 << 4 | Rm;
+}
+inline int XFER(int cond,
+                int P,
+                int U,
+                int B,
+                int W,
+                int L,
+                int Rn,
+                int Rd,
+                int shift,
+                int Sh,
+                int Rm)
+{
+  return cond << 28 | 3 << 25 | P << 24 | U << 23 | B << 22 | W << 21 | L << 20
+         | Rn << 16 | Rd << 12 | shift << 7 | Sh << 5 | Rm;
+}
+inline int XFERI(int cond,
+                 int P,
+                 int U,
+                 int B,
+                 int W,
+                 int L,
+                 int Rn,
+                 int Rd,
+                 int offset)
+{
+  return cond << 28 | 2 << 25 | P << 24 | U << 23 | B << 22 | W << 21 | L << 20
+         | Rn << 16 | Rd << 12 | (offset & 0xfff);
+}
+inline int XFER2(int cond,
+                 int P,
+                 int U,
+                 int W,
+                 int L,
+                 int Rn,
+                 int Rd,
+                 int S,
+                 int H,
+                 int Rm)
+{
+  return cond << 28 | P << 24 | U << 23 | W << 21 | L << 20 | Rn << 16
+         | Rd << 12 | 1 << 7 | S << 6 | H << 5 | 1 << 4 | Rm;
+}
+inline int XFER2I(int cond,
+                  int P,
+                  int U,
+                  int W,
+                  int L,
+                  int Rn,
+                  int Rd,
+                  int offsetH,
+                  int S,
+                  int H,
+                  int offsetL)
+{
+  return cond << 28 | P << 24 | U << 23 | 1 << 22 | W << 21 | L << 20 | Rn << 16
+         | Rd << 12 | offsetH << 8 | 1 << 7 | S << 6 | H << 5 | 1 << 4
+         | (offsetL & 0xf);
+}
+inline int COOP(int cond,
+                int opcode_1,
+                int CRn,
+                int CRd,
+                int cp_num,
+                int opcode_2,
+                int CRm)
+{
+  return cond << 28 | 0xe << 24 | opcode_1 << 20 | CRn << 16 | CRd << 12
+         | cp_num << 8 | opcode_2 << 5 | CRm;
+}
+inline int COXFER(int cond,
+                  int P,
+                  int U,
+                  int N,
+                  int W,
+                  int L,
+                  int Rn,
+                  int CRd,
+                  int cp_num,
+                  int offset)  // offset is in words, not bytes
+{
+  return cond << 28 | 0x6 << 25 | P << 24 | U << 23 | N << 22 | W << 21
+         | L << 20 | Rn << 16 | CRd << 12 | cp_num << 8 | (offset & 0xff) >> 2;
+}
+inline int COREG(int cond,
+                 int opcode_1,
+                 int L,
+                 int CRn,
+                 int Rd,
+                 int cp_num,
+                 int opcode_2,
+                 int CRm)
+{
+  return cond << 28 | 0xe << 24 | opcode_1 << 21 | L << 20 | CRn << 16
+         | Rd << 12 | cp_num << 8 | opcode_2 << 5 | 1 << 4 | CRm;
+}
+inline int
+    COREG2(int cond, int L, int Rn, int Rd, int cp_num, int opcode, int CRm)
+{
+  return cond << 28 | 0xc4 << 20 | L << 20 | Rn << 16 | Rd << 12 | cp_num << 8
+         | opcode << 4 | CRm;
+}
 // FIELD CALCULATORS
-inline int calcU(int imm) { return imm >= 0 ? 1 : 0; }
+inline int calcU(int imm)
+{
+  return imm >= 0 ? 1 : 0;
+}
 // INSTRUCTIONS
 // The "cond" and "S" fields are set using the SETCOND() and SETS() functions
-inline int b(int offset) { return BRANCH(AL, 0, offset); }
-inline int bl(int offset) { return BRANCH(AL, 1, offset); }
-inline int bx(int Rm) { return BRANCHX(AL, 0, Rm); }
-inline int blx(int Rm) { return BRANCHX(AL, 1, Rm); }
-inline int and_(int Rd, int Rn, int Rm, int Sh=0, int shift=0) { return DATA(AL, 0x0, 0, Rn, Rd, shift, Sh, Rm); }
-inline int eor(int Rd, int Rn, int Rm, int Sh=0, int shift=0) { return DATA(AL, 0x1, 0, Rn, Rd, shift, Sh, Rm); }
-inline int rsb(int Rd, int Rn, int Rm, int Sh=0, int shift=0) { return DATA(AL, 0x3, 0, Rn, Rd, shift, Sh, Rm); }
-inline int add(int Rd, int Rn, int Rm, int Sh=0, int shift=0) { return DATA(AL, 0x4, 0, Rn, Rd, shift, Sh, Rm); }
-inline int adc(int Rd, int Rn, int Rm, int Sh=0, int shift=0) { return DATA(AL, 0x5, 0, Rn, Rd, shift, Sh, Rm); }
-inline int rsc(int Rd, int Rn, int Rm, int Sh=0, int shift=0) { return DATA(AL, 0x7, 0, Rn, Rd, shift, Sh, Rm); }
-inline int cmp(int Rn, int Rm, int Sh=0, int shift=0) { return DATA(AL, 0xa, 1, Rn, 0, shift, Sh, Rm); }
-inline int orr(int Rd, int Rn, int Rm, int Sh=0, int shift=0) { return DATA(AL, 0xc, 0, Rn, Rd, shift, Sh, Rm); }
-inline int mov(int Rd, int Rm, int Sh=0, int shift=0) { return DATA(AL, 0xd, 0, 0, Rd, shift, Sh, Rm); }
-inline int mvn(int Rd, int Rm, int Sh=0, int shift=0) { return DATA(AL, 0xf, 0, 0, Rd, shift, Sh, Rm); }
-inline int andi(int Rd, int Rn, int imm, int rot=0) { return DATAI(AL, 0x0, 0, Rn, Rd, rot, imm); }
-inline int subi(int Rd, int Rn, int imm, int rot=0) { return DATAI(AL, 0x2, 0, Rn, Rd, rot, imm); }
-inline int rsbi(int Rd, int Rn, int imm, int rot=0) { return DATAI(AL, 0x3, 0, Rn, Rd, rot, imm); }
-inline int addi(int Rd, int Rn, int imm, int rot=0) { return DATAI(AL, 0x4, 0, Rn, Rd, rot, imm); }
-inline int adci(int Rd, int Rn, int imm, int rot=0) { return DATAI(AL, 0x5, 0, Rn, Rd, rot, imm); }
-inline int bici(int Rd, int Rn, int imm, int rot=0) { return DATAI(AL, 0xe, 0, Rn, Rd, rot, imm); }
-inline int cmpi(int Rn, int imm, int rot=0) { return DATAI(AL, 0xa, 1, Rn, 0, rot, imm); }
-inline int movi(int Rd, int imm, int rot=0) { return DATAI(AL, 0xd, 0, 0, Rd, rot, imm); }
-inline int orrsh(int Rd, int Rn, int Rm, int Rs, int Sh) { return DATAS(AL, 0xc, 0, Rn, Rd, Rs, Sh, Rm); }
-inline int movsh(int Rd, int Rm, int Rs, int Sh) { return DATAS(AL, 0xd, 0, 0, Rd, Rs, Sh, Rm); }
-inline int mul(int Rd, int Rm, int Rs) { return MULTIPLY(AL, 0, 0, Rd, 0, Rs, Rm); }
-inline int mla(int Rd, int Rm, int Rs, int Rn) { return MULTIPLY(AL, 1, 0, Rd, Rn, Rs, Rm); }
-inline int umull(int RdLo, int RdHi, int Rm, int Rs) { return MULTIPLY(AL, 4, 0, RdHi, RdLo, Rs, Rm); }
-inline int ldr(int Rd, int Rn, int Rm, int W=0) { return XFER(AL, 1, 1, 0, W, 1, Rn, Rd, 0, 0, Rm); }
-inline int ldri(int Rd, int Rn, int imm, int W=0) { return XFERI(AL, 1, calcU(imm), 0, W, 1, Rn, Rd, abs(imm)); }
-inline int ldrb(int Rd, int Rn, int Rm) { return XFER(AL, 1, 1, 1, 0, 1, Rn, Rd, 0, 0, Rm); }
-inline int ldrbi(int Rd, int Rn, int imm) { return XFERI(AL, 1, calcU(imm), 1, 0, 1, Rn, Rd, abs(imm)); }
-inline int str(int Rd, int Rn, int Rm, int W=0) { return XFER(AL, 1, 1, 0, W, 0, Rn, Rd, 0, 0, Rm); }
-inline int stri(int Rd, int Rn, int imm, int W=0) { return XFERI(AL, 1, calcU(imm), 0, W, 0, Rn, Rd, abs(imm)); }
-inline int strb(int Rd, int Rn, int Rm) { return XFER(AL, 1, 1, 1, 0, 0, Rn, Rd, 0, 0, Rm); }
-inline int strbi(int Rd, int Rn, int imm) { return XFERI(AL, 1, calcU(imm), 1, 0, 0, Rn, Rd, abs(imm)); }
-inline int ldrh(int Rd, int Rn, int Rm) { return XFER2(AL, 1, 1, 0, 1, Rn, Rd, 0, 1, Rm); }
-inline int ldrhi(int Rd, int Rn, int imm) { return XFER2I(AL, 1, calcU(imm), 0, 1, Rn, Rd, abs(imm)>>4 & 0xf, 0, 1, abs(imm)&0xf); }
-inline int strh(int Rd, int Rn, int Rm) { return XFER2(AL, 1, 1, 0, 0, Rn, Rd, 0, 1, Rm); }
-inline int strhi(int Rd, int Rn, int imm) { return XFER2I(AL, 1, calcU(imm), 0, 0, Rn, Rd, abs(imm)>>4 & 0xf, 0, 1, abs(imm)&0xf); }
-inline int ldrsh(int Rd, int Rn, int Rm) { return XFER2(AL, 1, 1, 0, 1, Rn, Rd, 1, 1, Rm); }
-inline int ldrshi(int Rd, int Rn, int imm) { return XFER2I(AL, 1, calcU(imm), 0, 1, Rn, Rd, abs(imm)>>4 & 0xf, 1, 1, abs(imm)&0xf); }
-inline int ldrsb(int Rd, int Rn, int Rm) { return XFER2(AL, 1, 1, 0, 1, Rn, Rd, 1, 0, Rm); }
-inline int ldrsbi(int Rd, int Rn, int imm) { return XFER2I(AL, 1, calcU(imm), 0, 1, Rn, Rd, abs(imm)>>4 & 0xf, 1, 0, abs(imm)&0xf); }
+inline int b(int offset)
+{
+  return BRANCH(AL, 0, offset);
+}
+inline int bl(int offset)
+{
+  return BRANCH(AL, 1, offset);
+}
+inline int bx(int Rm)
+{
+  return BRANCHX(AL, 0, Rm);
+}
+inline int blx(int Rm)
+{
+  return BRANCHX(AL, 1, Rm);
+}
+inline int and_(int Rd, int Rn, int Rm, int Sh = 0, int shift = 0)
+{
+  return DATA(AL, 0x0, 0, Rn, Rd, shift, Sh, Rm);
+}
+inline int eor(int Rd, int Rn, int Rm, int Sh = 0, int shift = 0)
+{
+  return DATA(AL, 0x1, 0, Rn, Rd, shift, Sh, Rm);
+}
+inline int rsb(int Rd, int Rn, int Rm, int Sh = 0, int shift = 0)
+{
+  return DATA(AL, 0x3, 0, Rn, Rd, shift, Sh, Rm);
+}
+inline int add(int Rd, int Rn, int Rm, int Sh = 0, int shift = 0)
+{
+  return DATA(AL, 0x4, 0, Rn, Rd, shift, Sh, Rm);
+}
+inline int adc(int Rd, int Rn, int Rm, int Sh = 0, int shift = 0)
+{
+  return DATA(AL, 0x5, 0, Rn, Rd, shift, Sh, Rm);
+}
+inline int rsc(int Rd, int Rn, int Rm, int Sh = 0, int shift = 0)
+{
+  return DATA(AL, 0x7, 0, Rn, Rd, shift, Sh, Rm);
+}
+inline int cmp(int Rn, int Rm, int Sh = 0, int shift = 0)
+{
+  return DATA(AL, 0xa, 1, Rn, 0, shift, Sh, Rm);
+}
+inline int orr(int Rd, int Rn, int Rm, int Sh = 0, int shift = 0)
+{
+  return DATA(AL, 0xc, 0, Rn, Rd, shift, Sh, Rm);
+}
+inline int mov(int Rd, int Rm, int Sh = 0, int shift = 0)
+{
+  return DATA(AL, 0xd, 0, 0, Rd, shift, Sh, Rm);
+}
+inline int mvn(int Rd, int Rm, int Sh = 0, int shift = 0)
+{
+  return DATA(AL, 0xf, 0, 0, Rd, shift, Sh, Rm);
+}
+inline int andi(int Rd, int Rn, int imm, int rot = 0)
+{
+  return DATAI(AL, 0x0, 0, Rn, Rd, rot, imm);
+}
+inline int subi(int Rd, int Rn, int imm, int rot = 0)
+{
+  return DATAI(AL, 0x2, 0, Rn, Rd, rot, imm);
+}
+inline int rsbi(int Rd, int Rn, int imm, int rot = 0)
+{
+  return DATAI(AL, 0x3, 0, Rn, Rd, rot, imm);
+}
+inline int addi(int Rd, int Rn, int imm, int rot = 0)
+{
+  return DATAI(AL, 0x4, 0, Rn, Rd, rot, imm);
+}
+inline int adci(int Rd, int Rn, int imm, int rot = 0)
+{
+  return DATAI(AL, 0x5, 0, Rn, Rd, rot, imm);
+}
+inline int bici(int Rd, int Rn, int imm, int rot = 0)
+{
+  return DATAI(AL, 0xe, 0, Rn, Rd, rot, imm);
+}
+inline int cmpi(int Rn, int imm, int rot = 0)
+{
+  return DATAI(AL, 0xa, 1, Rn, 0, rot, imm);
+}
+inline int movi(int Rd, int imm, int rot = 0)
+{
+  return DATAI(AL, 0xd, 0, 0, Rd, rot, imm);
+}
+inline int orrsh(int Rd, int Rn, int Rm, int Rs, int Sh)
+{
+  return DATAS(AL, 0xc, 0, Rn, Rd, Rs, Sh, Rm);
+}
+inline int movsh(int Rd, int Rm, int Rs, int Sh)
+{
+  return DATAS(AL, 0xd, 0, 0, Rd, Rs, Sh, Rm);
+}
+inline int mul(int Rd, int Rm, int Rs)
+{
+  return MULTIPLY(AL, 0, 0, Rd, 0, Rs, Rm);
+}
+inline int mla(int Rd, int Rm, int Rs, int Rn)
+{
+  return MULTIPLY(AL, 1, 0, Rd, Rn, Rs, Rm);
+}
+inline int umull(int RdLo, int RdHi, int Rm, int Rs)
+{
+  return MULTIPLY(AL, 4, 0, RdHi, RdLo, Rs, Rm);
+}
+inline int ldr(int Rd, int Rn, int Rm, int W = 0)
+{
+  return XFER(AL, 1, 1, 0, W, 1, Rn, Rd, 0, 0, Rm);
+}
+inline int ldri(int Rd, int Rn, int imm, int W = 0)
+{
+  return XFERI(AL, 1, calcU(imm), 0, W, 1, Rn, Rd, abs(imm));
+}
+inline int ldrb(int Rd, int Rn, int Rm)
+{
+  return XFER(AL, 1, 1, 1, 0, 1, Rn, Rd, 0, 0, Rm);
+}
+inline int ldrbi(int Rd, int Rn, int imm)
+{
+  return XFERI(AL, 1, calcU(imm), 1, 0, 1, Rn, Rd, abs(imm));
+}
+inline int str(int Rd, int Rn, int Rm, int W = 0)
+{
+  return XFER(AL, 1, 1, 0, W, 0, Rn, Rd, 0, 0, Rm);
+}
+inline int stri(int Rd, int Rn, int imm, int W = 0)
+{
+  return XFERI(AL, 1, calcU(imm), 0, W, 0, Rn, Rd, abs(imm));
+}
+inline int strb(int Rd, int Rn, int Rm)
+{
+  return XFER(AL, 1, 1, 1, 0, 0, Rn, Rd, 0, 0, Rm);
+}
+inline int strbi(int Rd, int Rn, int imm)
+{
+  return XFERI(AL, 1, calcU(imm), 1, 0, 0, Rn, Rd, abs(imm));
+}
+inline int ldrh(int Rd, int Rn, int Rm)
+{
+  return XFER2(AL, 1, 1, 0, 1, Rn, Rd, 0, 1, Rm);
+}
+inline int ldrhi(int Rd, int Rn, int imm)
+{
+  return XFER2I(AL,
+                1,
+                calcU(imm),
+                0,
+                1,
+                Rn,
+                Rd,
+                abs(imm) >> 4 & 0xf,
+                0,
+                1,
+                abs(imm) & 0xf);
+}
+inline int strh(int Rd, int Rn, int Rm)
+{
+  return XFER2(AL, 1, 1, 0, 0, Rn, Rd, 0, 1, Rm);
+}
+inline int strhi(int Rd, int Rn, int imm)
+{
+  return XFER2I(AL,
+                1,
+                calcU(imm),
+                0,
+                0,
+                Rn,
+                Rd,
+                abs(imm) >> 4 & 0xf,
+                0,
+                1,
+                abs(imm) & 0xf);
+}
+inline int ldrsh(int Rd, int Rn, int Rm)
+{
+  return XFER2(AL, 1, 1, 0, 1, Rn, Rd, 1, 1, Rm);
+}
+inline int ldrshi(int Rd, int Rn, int imm)
+{
+  return XFER2I(AL,
+                1,
+                calcU(imm),
+                0,
+                1,
+                Rn,
+                Rd,
+                abs(imm) >> 4 & 0xf,
+                1,
+                1,
+                abs(imm) & 0xf);
+}
+inline int ldrsb(int Rd, int Rn, int Rm)
+{
+  return XFER2(AL, 1, 1, 0, 1, Rn, Rd, 1, 0, Rm);
+}
+inline int ldrsbi(int Rd, int Rn, int imm)
+{
+  return XFER2I(AL,
+                1,
+                calcU(imm),
+                0,
+                1,
+                Rn,
+                Rd,
+                abs(imm) >> 4 & 0xf,
+                1,
+                0,
+                abs(imm) & 0xf);
+}
 // breakpoint instruction, this really has its own instruction format
-inline int bkpt(int16_t immed) { return 0xe1200070 | (((unsigned)immed & 0xffff) >> 4 << 8) | (immed & 0xf); }
+inline int bkpt(int16_t immed)
+{
+  return 0xe1200070 | (((unsigned)immed & 0xffff) >> 4 << 8) | (immed & 0xf);
+}
 // COPROCESSOR INSTRUCTIONS
-inline int mcr(int coproc, int opcode_1, int Rd, int CRn, int CRm, int opcode_2=0) { return COREG(AL, opcode_1, 0, CRn, Rd, coproc, opcode_2, CRm); }
-inline int mcrr(int coproc, int opcode, int Rd, int Rn, int CRm) { return COREG2(AL, 0, Rn, Rd, coproc, opcode, CRm); }
-inline int mrc(int coproc, int opcode_1, int Rd, int CRn, int CRm, int opcode_2=0) { return COREG(AL, opcode_1, 1, CRn, Rd, coproc, opcode_2, CRm); }
-inline int mrrc(int coproc, int opcode, int Rd, int Rn, int CRm) { return COREG2(AL, 1, Rn, Rd, coproc, opcode, CRm); }
+inline int mcr(int coproc,
+               int opcode_1,
+               int Rd,
+               int CRn,
+               int CRm,
+               int opcode_2 = 0)
+{
+  return COREG(AL, opcode_1, 0, CRn, Rd, coproc, opcode_2, CRm);
+}
+inline int mcrr(int coproc, int opcode, int Rd, int Rn, int CRm)
+{
+  return COREG2(AL, 0, Rn, Rd, coproc, opcode, CRm);
+}
+inline int mrc(int coproc,
+               int opcode_1,
+               int Rd,
+               int CRn,
+               int CRm,
+               int opcode_2 = 0)
+{
+  return COREG(AL, opcode_1, 1, CRn, Rd, coproc, opcode_2, CRm);
+}
+inline int mrrc(int coproc, int opcode, int Rd, int Rn, int CRm)
+{
+  return COREG2(AL, 1, Rn, Rd, coproc, opcode, CRm);
+}
 // VFP FLOATING-POINT INSTRUCTIONS
-inline int fmuls(int Sd, int Sn, int Sm) { return COOP(AL, (Sd&1)<<2|2, Sn>>1, Sd>>1, 10, (Sn&1)<<2|(Sm&1), Sm>>1); }
-inline int fadds(int Sd, int Sn, int Sm) { return COOP(AL, (Sd&1)<<2|3, Sn>>1, Sd>>1, 10, (Sn&1)<<2|(Sm&1), Sm>>1); }
-inline int fsubs(int Sd, int Sn, int Sm) { return COOP(AL, (Sd&1)<<2|3, Sn>>1, Sd>>1, 10, (Sn&1)<<2|(Sm&1)|2, Sm>>1); }
-inline int fdivs(int Sd, int Sn, int Sm) { return COOP(AL, (Sd&1)<<2|8, Sn>>1, Sd>>1, 10, (Sn&1)<<2|(Sm&1), Sm>>1); }
-inline int fmuld(int Dd, int Dn, int Dm) { return COOP(AL, 2, Dn, Dd, 11, 0, Dm); }
-inline int faddd(int Dd, int Dn, int Dm) { return COOP(AL, 3, Dn, Dd, 11, 0, Dm); }
-inline int fsubd(int Dd, int Dn, int Dm) { return COOP(AL, 3, Dn, Dd, 11, 2, Dm); }
-inline int fdivd(int Dd, int Dn, int Dm) { return COOP(AL, 8, Dn, Dd, 11, 0, Dm); }
-inline int fcpys(int Sd, int Sm) { return COOP(AL, 0xb|(Sd&1)<<2, 0, Sd>>1, 10, 2|(Sm&1), Sm>>1); }
-inline int fabss(int Sd, int Sm) { return COOP(AL, 0xb|(Sd&1)<<2, 0, Sd>>1, 10, 6|(Sm&1), Sm>>1); }
-inline int fnegs(int Sd, int Sm) { return COOP(AL, 0xb|(Sd&1)<<2, 1, Sd>>1, 10, 2|(Sm&1), Sm>>1); }
-inline int fsqrts(int Sd, int Sm) { return COOP(AL, 0xb|(Sd&1)<<2, 1, Sd>>1, 10, 6|(Sm&1), Sm>>1); }
-inline int fcmps(int Sd, int Sm) { return COOP(AL, 0xb|(Sd&1)<<2, 4, Sd>>1, 10, 2|(Sm&1), Sm>>1); }
-inline int fcvtds(int Dd, int Sm) { return COOP(AL, 0xb, 7, Dd, 10, 6|(Sm&1), Sm>>1); }
-inline int fsitos(int Sd, int Sm) { return COOP(AL, 0xb|(Sd&1)<<2, 8, Sd>>1, 10, 6|(Sm&1), Sm>>1); }
-inline int ftosizs(int Sd, int Sm) { return COOP(AL, 0xb|(Sd&1)<<2, 0xd, Sd>>1, 10, 6|(Sm&1), Sm>>1); }
-inline int fcpyd(int Dd, int Dm) { return COOP(AL, 0xb, 0, Dd, 11, 2, Dm); }
-inline int fabsd(int Dd, int Dm) { return COOP(AL, 0xb, 0, Dd, 11, 6, Dm); }
-inline int fnegd(int Dd, int Dm) { return COOP(AL, 0xb, 1, Dd, 11, 2, Dm); }
-inline int fsqrtd(int Dd, int Dm) { return COOP(AL, 0xb, 1, Dd, 11, 6, Dm); }
+inline int fmuls(int Sd, int Sn, int Sm)
+{
+  return COOP(AL,
+              (Sd & 1) << 2 | 2,
+              Sn >> 1,
+              Sd >> 1,
+              10,
+              (Sn & 1) << 2 | (Sm & 1),
+              Sm >> 1);
+}
+inline int fadds(int Sd, int Sn, int Sm)
+{
+  return COOP(AL,
+              (Sd & 1) << 2 | 3,
+              Sn >> 1,
+              Sd >> 1,
+              10,
+              (Sn & 1) << 2 | (Sm & 1),
+              Sm >> 1);
+}
+inline int fsubs(int Sd, int Sn, int Sm)
+{
+  return COOP(AL,
+              (Sd & 1) << 2 | 3,
+              Sn >> 1,
+              Sd >> 1,
+              10,
+              (Sn & 1) << 2 | (Sm & 1) | 2,
+              Sm >> 1);
+}
+inline int fdivs(int Sd, int Sn, int Sm)
+{
+  return COOP(AL,
+              (Sd & 1) << 2 | 8,
+              Sn >> 1,
+              Sd >> 1,
+              10,
+              (Sn & 1) << 2 | (Sm & 1),
+              Sm >> 1);
+}
+inline int fmuld(int Dd, int Dn, int Dm)
+{
+  return COOP(AL, 2, Dn, Dd, 11, 0, Dm);
+}
+inline int faddd(int Dd, int Dn, int Dm)
+{
+  return COOP(AL, 3, Dn, Dd, 11, 0, Dm);
+}
+inline int fsubd(int Dd, int Dn, int Dm)
+{
+  return COOP(AL, 3, Dn, Dd, 11, 2, Dm);
+}
+inline int fdivd(int Dd, int Dn, int Dm)
+{
+  return COOP(AL, 8, Dn, Dd, 11, 0, Dm);
+}
+inline int fcpys(int Sd, int Sm)
+{
+  return COOP(AL, 0xb | (Sd & 1) << 2, 0, Sd >> 1, 10, 2 | (Sm & 1), Sm >> 1);
+}
+inline int fabss(int Sd, int Sm)
+{
+  return COOP(AL, 0xb | (Sd & 1) << 2, 0, Sd >> 1, 10, 6 | (Sm & 1), Sm >> 1);
+}
+inline int fnegs(int Sd, int Sm)
+{
+  return COOP(AL, 0xb | (Sd & 1) << 2, 1, Sd >> 1, 10, 2 | (Sm & 1), Sm >> 1);
+}
+inline int fsqrts(int Sd, int Sm)
+{
+  return COOP(AL, 0xb | (Sd & 1) << 2, 1, Sd >> 1, 10, 6 | (Sm & 1), Sm >> 1);
+}
+inline int fcmps(int Sd, int Sm)
+{
+  return COOP(AL, 0xb | (Sd & 1) << 2, 4, Sd >> 1, 10, 2 | (Sm & 1), Sm >> 1);
+}
+inline int fcvtds(int Dd, int Sm)
+{
+  return COOP(AL, 0xb, 7, Dd, 10, 6 | (Sm & 1), Sm >> 1);
+}
+inline int fsitos(int Sd, int Sm)
+{
+  return COOP(AL, 0xb | (Sd & 1) << 2, 8, Sd >> 1, 10, 6 | (Sm & 1), Sm >> 1);
+}
+inline int ftosizs(int Sd, int Sm)
+{
+  return COOP(AL, 0xb | (Sd & 1) << 2, 0xd, Sd >> 1, 10, 6 | (Sm & 1), Sm >> 1);
+}
+inline int fcpyd(int Dd, int Dm)
+{
+  return COOP(AL, 0xb, 0, Dd, 11, 2, Dm);
+}
+inline int fabsd(int Dd, int Dm)
+{
+  return COOP(AL, 0xb, 0, Dd, 11, 6, Dm);
+}
+inline int fnegd(int Dd, int Dm)
+{
+  return COOP(AL, 0xb, 1, Dd, 11, 2, Dm);
+}
+inline int fsqrtd(int Dd, int Dm)
+{
+  return COOP(AL, 0xb, 1, Dd, 11, 6, Dm);
+}
 // double-precision comparison instructions
-inline int fcmpd(int Dd, int Dm) { return COOP(AL, 0xb, 4, Dd, 11, 2, Dm); }
+inline int fcmpd(int Dd, int Dm)
+{
+  return COOP(AL, 0xb, 4, Dd, 11, 2, Dm);
+}
 // double-precision conversion instructions
-inline int fcvtsd(int Sd, int Dm) { return COOP(AL, 0xb|(Sd&1)<<2, 7, Sd>>1, 11, 6, Dm); }
-inline int fsitod(int Dd, int Sm) { return COOP(AL, 0xb, 8, Dd, 11, 6|(Sm&1), Sm>>1); }
-inline int ftosizd(int Sd, int Dm) { return COOP(AL, 0xb|(Sd&1)<<2, 0xd, Sd>>1, 11, 6, Dm); }
+inline int fcvtsd(int Sd, int Dm)
+{
+  return COOP(AL, 0xb | (Sd & 1) << 2, 7, Sd >> 1, 11, 6, Dm);
+}
+inline int fsitod(int Dd, int Sm)
+{
+  return COOP(AL, 0xb, 8, Dd, 11, 6 | (Sm & 1), Sm >> 1);
+}
+inline int ftosizd(int Sd, int Dm)
+{
+  return COOP(AL, 0xb | (Sd & 1) << 2, 0xd, Sd >> 1, 11, 6, Dm);
+}
 // single load/store instructions for both precision types
-inline int flds(int Sd, int Rn, int offset=0) { return COXFER(AL, 1, 1, Sd&1, 0, 1, Rn, Sd>>1, 10, offset); };
-inline int fldd(int Dd, int Rn, int offset=0) { return COXFER(AL, 1, 1, 0, 0, 1, Rn, Dd, 11, offset); };
-inline int fsts(int Sd, int Rn, int offset=0) { return COXFER(AL, 1, 1, Sd&1, 0, 0, Rn, Sd>>1, 10, offset); };
-inline int fstd(int Dd, int Rn, int offset=0) { return COXFER(AL, 1, 1, 0, 0, 0, Rn, Dd, 11, offset); };
+inline int flds(int Sd, int Rn, int offset = 0)
+{
+  return COXFER(AL, 1, 1, Sd & 1, 0, 1, Rn, Sd >> 1, 10, offset);
+};
+inline int fldd(int Dd, int Rn, int offset = 0)
+{
+  return COXFER(AL, 1, 1, 0, 0, 1, Rn, Dd, 11, offset);
+};
+inline int fsts(int Sd, int Rn, int offset = 0)
+{
+  return COXFER(AL, 1, 1, Sd & 1, 0, 0, Rn, Sd >> 1, 10, offset);
+};
+inline int fstd(int Dd, int Rn, int offset = 0)
+{
+  return COXFER(AL, 1, 1, 0, 0, 0, Rn, Dd, 11, offset);
+};
 // move between GPRs and FPRs
-inline int fmsr(int Sn, int Rd) { return mcr(10, 0, Rd, Sn>>1, 0, (Sn&1)<<2); }
-inline int fmrs(int Rd, int Sn) { return mrc(10, 0, Rd, Sn>>1, 0, (Sn&1)<<2); }
+inline int fmsr(int Sn, int Rd)
+{
+  return mcr(10, 0, Rd, Sn >> 1, 0, (Sn & 1) << 2);
+}
+inline int fmrs(int Rd, int Sn)
+{
+  return mrc(10, 0, Rd, Sn >> 1, 0, (Sn & 1) << 2);
+}
 // move to/from VFP system registers
-inline int fmrx(int Rd, int reg) { return mrc(10, 7, Rd, reg, 0); }
+inline int fmrx(int Rd, int reg)
+{
+  return mrc(10, 7, Rd, reg, 0);
+}
 // these move around pairs of single-precision registers
-inline int fmdrr(int Dm, int Rd, int Rn) { return mcrr(11, 1, Rd, Rn, Dm); }
-inline int fmrrd(int Rd, int Rn, int Dm) { return mrrc(11, 1, Rd, Rn, Dm); }
+inline int fmdrr(int Dm, int Rd, int Rn)
+{
+  return mcrr(11, 1, Rd, Rn, Dm);
+}
+inline int fmrrd(int Rd, int Rn, int Dm)
+{
+  return mrrc(11, 1, Rd, Rn, Dm);
+}
 // FLAG SETTERS
-inline int SETCOND(int ins, int cond) { return ((ins&0x0fffffff) | (cond<<28)); }
-inline int SETS(int ins) { return ins | 1<<20; }
+inline int SETCOND(int ins, int cond)
+{
+  return ((ins & 0x0fffffff) | (cond << 28));
+}
+inline int SETS(int ins)
+{
+  return ins | 1 << 20;
+}
 // PSEUDO-INSTRUCTIONS
-inline int lsl(int Rd, int Rm, int Rs) { return movsh(Rd, Rm, Rs, LSL); }
-inline int lsli(int Rd, int Rm, int imm) { return mov(Rd, Rm, LSL, imm); }
-inline int lsr(int Rd, int Rm, int Rs) { return movsh(Rd, Rm, Rs, LSR); }
-inline int lsri(int Rd, int Rm, int imm) { return mov(Rd, Rm, LSR, imm); }
-inline int asr(int Rd, int Rm, int Rs) { return movsh(Rd, Rm, Rs, ASR); }
-inline int asri(int Rd, int Rm, int imm) { return mov(Rd, Rm, ASR, imm); }
-inline int beq(int offset) { return SETCOND(b(offset), EQ); }
-inline int bne(int offset) { return SETCOND(b(offset), NE); }
-inline int bls(int offset) { return SETCOND(b(offset), LS); }
-inline int bhi(int offset) { return SETCOND(b(offset), HI); }
-inline int blt(int offset) { return SETCOND(b(offset), LT); }
-inline int bgt(int offset) { return SETCOND(b(offset), GT); }
-inline int ble(int offset) { return SETCOND(b(offset), LE); }
-inline int bge(int offset) { return SETCOND(b(offset), GE); }
-inline int blo(int offset) { return SETCOND(b(offset), CC); }
-inline int bhs(int offset) { return SETCOND(b(offset), CS); }
-inline int bpl(int offset) { return SETCOND(b(offset), PL); }
-inline int fmstat() { return fmrx(15, FPSCR); }
+inline int lsl(int Rd, int Rm, int Rs)
+{
+  return movsh(Rd, Rm, Rs, LSL);
+}
+inline int lsli(int Rd, int Rm, int imm)
+{
+  return mov(Rd, Rm, LSL, imm);
+}
+inline int lsr(int Rd, int Rm, int Rs)
+{
+  return movsh(Rd, Rm, Rs, LSR);
+}
+inline int lsri(int Rd, int Rm, int imm)
+{
+  return mov(Rd, Rm, LSR, imm);
+}
+inline int asr(int Rd, int Rm, int Rs)
+{
+  return movsh(Rd, Rm, Rs, ASR);
+}
+inline int asri(int Rd, int Rm, int imm)
+{
+  return mov(Rd, Rm, ASR, imm);
+}
+inline int beq(int offset)
+{
+  return SETCOND(b(offset), EQ);
+}
+inline int bne(int offset)
+{
+  return SETCOND(b(offset), NE);
+}
+inline int bls(int offset)
+{
+  return SETCOND(b(offset), LS);
+}
+inline int bhi(int offset)
+{
+  return SETCOND(b(offset), HI);
+}
+inline int blt(int offset)
+{
+  return SETCOND(b(offset), LT);
+}
+inline int bgt(int offset)
+{
+  return SETCOND(b(offset), GT);
+}
+inline int ble(int offset)
+{
+  return SETCOND(b(offset), LE);
+}
+inline int bge(int offset)
+{
+  return SETCOND(b(offset), GE);
+}
+inline int blo(int offset)
+{
+  return SETCOND(b(offset), CC);
+}
+inline int bhs(int offset)
+{
+  return SETCOND(b(offset), CS);
+}
+inline int bpl(int offset)
+{
+  return SETCOND(b(offset), PL);
+}
+inline int fmstat()
+{
+  return fmrx(15, FPSCR);
+}
 // todo: make this pretty:
-inline int dmb() { return 0xf57ff05f; }
+inline int dmb()
+{
+  return 0xf57ff05f;
+}
 
-} // namespace isa
+}  // namespace isa
 
-inline void emit(Context* con, int code) { con->code.append4(code); }
+inline void emit(Context* con, int code)
+{
+  con->code.append4(code);
+}
 
-} // namespace arm
-} // namespace codegen
-} // namespace avian
+}  // namespace arm
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_ASSEMBLER_ARM_ENCODE_H
+#endif  // AVIAN_CODEGEN_ASSEMBLER_ARM_ENCODE_H
diff --git a/src/codegen/target/arm/fixup.cpp b/src/codegen/target/arm/fixup.cpp
index 96f96228c5..e1d41b6eb4 100644
--- a/src/codegen/target/arm/fixup.cpp
+++ b/src/codegen/target/arm/fixup.cpp
@@ -20,65 +20,78 @@ using namespace util;
 
 unsigned padding(MyBlock*, unsigned);
 
-OffsetPromise::OffsetPromise(Context* con, MyBlock* block, unsigned offset, bool forTrace):
-  con(con), block(block), offset(offset), forTrace(forTrace)
-{ }
+OffsetPromise::OffsetPromise(Context* con,
+                             MyBlock* block,
+                             unsigned offset,
+                             bool forTrace)
+    : con(con), block(block), offset(offset), forTrace(forTrace)
+{
+}
 
-bool OffsetPromise::resolved() {
+bool OffsetPromise::resolved()
+{
   return block->start != static_cast<unsigned>(~0);
 }
 
-int64_t OffsetPromise::value() {
+int64_t OffsetPromise::value()
+{
   assertT(con, resolved());
 
   unsigned o = offset - block->offset;
-  return block->start + padding
-    (block, forTrace ? o - vm::TargetBytesPerWord : o) + o;
+  return block->start
+         + padding(block, forTrace ? o - vm::TargetBytesPerWord : o) + o;
 }
 
-
-Promise* offsetPromise(Context* con, bool forTrace) {
-  return new(con->zone) OffsetPromise(con, con->lastBlock, con->code.length(), forTrace);
+Promise* offsetPromise(Context* con, bool forTrace)
+{
+  return new (con->zone)
+      OffsetPromise(con, con->lastBlock, con->code.length(), forTrace);
 }
 
+OffsetListener::OffsetListener(vm::System* s, uint8_t* instruction)
+    : s(s), instruction(instruction)
+{
+}
 
-OffsetListener::OffsetListener(vm::System* s, uint8_t* instruction):
-  s(s),
-  instruction(instruction)
-{ }
-
-bool OffsetListener::resolve(int64_t value, void** location) {
+bool OffsetListener::resolve(int64_t value, void** location)
+{
   void* p = updateOffset(s, instruction, value);
-  if (location) *location = p;
+  if (location)
+    *location = p;
   return false;
 }
 
+OffsetTask::OffsetTask(Task* next, Promise* promise, Promise* instructionOffset)
+    : Task(next), promise(promise), instructionOffset(instructionOffset)
+{
+}
 
-OffsetTask::OffsetTask(Task* next, Promise* promise, Promise* instructionOffset):
-  Task(next),
-  promise(promise),
-  instructionOffset(instructionOffset)
-{ }
-
-void OffsetTask::run(Context* con) {
+void OffsetTask::run(Context* con)
+{
   if (promise->resolved()) {
-    updateOffset
-      (con->s, con->result + instructionOffset->value(), promise->value());
+    updateOffset(
+        con->s, con->result + instructionOffset->value(), promise->value());
   } else {
     new (promise->listen(sizeof(OffsetListener)))
-      OffsetListener(con->s, con->result + instructionOffset->value());
+        OffsetListener(con->s, con->result + instructionOffset->value());
   }
 }
 
-void appendOffsetTask(Context* con, Promise* promise, Promise* instructionOffset) {
-  con->tasks = new(con->zone) OffsetTask(con->tasks, promise, instructionOffset);
+void appendOffsetTask(Context* con,
+                      Promise* promise,
+                      Promise* instructionOffset)
+{
+  con->tasks = new (con->zone)
+      OffsetTask(con->tasks, promise, instructionOffset);
 }
 
-bool bounded(int right, int left, int32_t v) {
+bool bounded(int right, int left, int32_t v)
+{
   return ((v << left) >> left) == v and ((v >> right) << right) == v;
 }
 
-void* updateOffset(vm::System* s, uint8_t* instruction, int64_t value) {
+void* updateOffset(vm::System* s, uint8_t* instruction, int64_t value)
+{
   // ARM's PC is two words ahead, and branches drop the bottom 2 bits.
   int32_t v = (reinterpret_cast<uint8_t*>(value) - (instruction + 8)) >> 2;
 
@@ -92,30 +105,39 @@ void* updateOffset(vm::System* s, uint8_t* instruction, int64_t value) {
   return instruction + 4;
 }
 
-ConstantPoolEntry::ConstantPoolEntry(Context* con, Promise* constant, ConstantPoolEntry* next,
-                  Promise* callOffset):
-  con(con), constant(constant), next(next), callOffset(callOffset),
-  address(0)
-{ }
+ConstantPoolEntry::ConstantPoolEntry(Context* con,
+                                     Promise* constant,
+                                     ConstantPoolEntry* next,
+                                     Promise* callOffset)
+    : con(con),
+      constant(constant),
+      next(next),
+      callOffset(callOffset),
+      address(0)
+{
+}
 
-int64_t ConstantPoolEntry::value() {
+int64_t ConstantPoolEntry::value()
+{
   assertT(con, resolved());
 
   return reinterpret_cast<int64_t>(address);
 }
 
-bool ConstantPoolEntry::resolved() {
+bool ConstantPoolEntry::resolved()
+{
   return address != 0;
 }
 
-ConstantPoolListener::ConstantPoolListener(vm::System* s, vm::target_uintptr_t* address,
-                     uint8_t* returnAddress):
-  s(s),
-  address(address),
-  returnAddress(returnAddress)
-{ }
+ConstantPoolListener::ConstantPoolListener(vm::System* s,
+                                           vm::target_uintptr_t* address,
+                                           uint8_t* returnAddress)
+    : s(s), address(address), returnAddress(returnAddress)
+{
+}
 
-bool ConstantPoolListener::resolve(int64_t value, void** location) {
+bool ConstantPoolListener::resolve(int64_t value, void** location)
+{
   *address = value;
   if (location) {
     *location = returnAddress ? static_cast<void*>(returnAddress) : address;
@@ -123,32 +145,49 @@ bool ConstantPoolListener::resolve(int64_t value, void** location) {
   return true;
 }
 
-PoolOffset::PoolOffset(MyBlock* block, ConstantPoolEntry* entry, unsigned offset):
-  block(block), entry(entry), next(0), offset(offset)
-{ }
+PoolOffset::PoolOffset(MyBlock* block,
+                       ConstantPoolEntry* entry,
+                       unsigned offset)
+    : block(block), entry(entry), next(0), offset(offset)
+{
+}
 
-PoolEvent::PoolEvent(PoolOffset* poolOffsetHead, PoolOffset* poolOffsetTail,
-          unsigned offset):
-  poolOffsetHead(poolOffsetHead), poolOffsetTail(poolOffsetTail), next(0),
-  offset(offset)
-{ }
+PoolEvent::PoolEvent(PoolOffset* poolOffsetHead,
+                     PoolOffset* poolOffsetTail,
+                     unsigned offset)
+    : poolOffsetHead(poolOffsetHead),
+      poolOffsetTail(poolOffsetTail),
+      next(0),
+      offset(offset)
+{
+}
 
-void appendConstantPoolEntry(Context* con, Promise* constant, Promise* callOffset) {
+void appendConstantPoolEntry(Context* con,
+                             Promise* constant,
+                             Promise* callOffset)
+{
   if (constant->resolved()) {
     // make a copy, since the original might be allocated on the
     // stack, and we need our copy to live until assembly is complete
-    constant = new(con->zone) ResolvedPromise(constant->value());
+    constant = new (con->zone) ResolvedPromise(constant->value());
   }
 
-  con->constantPool = new(con->zone) ConstantPoolEntry(con, constant, con->constantPool, callOffset);
+  con->constantPool = new (con->zone)
+      ConstantPoolEntry(con, constant, con->constantPool, callOffset);
 
-  ++ con->constantPoolCount;
+  ++con->constantPoolCount;
 
-  PoolOffset* o = new(con->zone) PoolOffset(con->lastBlock, con->constantPool, con->code.length() - con->lastBlock->offset);
+  PoolOffset* o = new (con->zone)
+      PoolOffset(con->lastBlock,
+                 con->constantPool,
+                 con->code.length() - con->lastBlock->offset);
 
   if (DebugPool) {
-    fprintf(stderr, "add pool offset %p %d to block %p\n",
-            o, o->offset, con->lastBlock);
+    fprintf(stderr,
+            "add pool offset %p %d to block %p\n",
+            o,
+            o->offset,
+            con->lastBlock);
   }
 
   if (con->lastBlock->poolOffsetTail) {
@@ -159,10 +198,13 @@ void appendConstantPoolEntry(Context* con, Promise* constant, Promise* callOffse
   con->lastBlock->poolOffsetTail = o;
 }
 
-void appendPoolEvent(Context* con, MyBlock* b, unsigned offset, PoolOffset* head,
-                PoolOffset* tail)
+void appendPoolEvent(Context* con,
+                     MyBlock* b,
+                     unsigned offset,
+                     PoolOffset* head,
+                     PoolOffset* tail)
 {
-  PoolEvent* e = new(con->zone) PoolEvent(head, tail, offset);
+  PoolEvent* e = new (con->zone) PoolEvent(head, tail, offset);
 
   if (b->poolEventTail) {
     b->poolEventTail->next = e;
@@ -172,6 +214,6 @@ void appendPoolEvent(Context* con, MyBlock* b, unsigned offset, PoolOffset* head
   b->poolEventTail = e;
 }
 
-} // namespace arm
-} // namespace codegen
-} // namespace avian
+}  // namespace arm
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/target/arm/fixup.h b/src/codegen/target/arm/fixup.h
index 43c32c821f..5460295d95 100644
--- a/src/codegen/target/arm/fixup.h
+++ b/src/codegen/target/arm/fixup.h
@@ -31,19 +31,21 @@ const int32_t PoolOffsetMask = 0xFFF;
 
 class Task {
  public:
-  Task(Task* next): next(next) { }
+  Task(Task* next) : next(next)
+  {
+  }
 
   virtual void run(Context* con) = 0;
 
   Task* next;
 };
 
-class OffsetPromise: public Promise {
+class OffsetPromise : public Promise {
  public:
   OffsetPromise(Context* con, MyBlock* block, unsigned offset, bool forTrace);
 
   virtual bool resolved();
-  
+
   virtual int64_t value();
 
   Context* con;
@@ -54,7 +56,7 @@ class OffsetPromise: public Promise {
 
 Promise* offsetPromise(Context* con, bool forTrace = false);
 
-class OffsetListener: public Promise::Listener {
+class OffsetListener : public Promise::Listener {
  public:
   OffsetListener(vm::System* s, uint8_t* instruction);
 
@@ -64,7 +66,7 @@ class OffsetListener: public Promise::Listener {
   uint8_t* instruction;
 };
 
-class OffsetTask: public Task {
+class OffsetTask : public Task {
  public:
   OffsetTask(Task* next, Promise* promise, Promise* instructionOffset);
 
@@ -74,13 +76,17 @@ class OffsetTask: public Task {
   Promise* instructionOffset;
 };
 
-void appendOffsetTask(Context* con, Promise* promise, Promise* instructionOffset);
+void appendOffsetTask(Context* con,
+                      Promise* promise,
+                      Promise* instructionOffset);
 
 void* updateOffset(vm::System* s, uint8_t* instruction, int64_t value);
 
-class ConstantPoolEntry: public Promise {
+class ConstantPoolEntry : public Promise {
  public:
-  ConstantPoolEntry(Context* con, Promise* constant, ConstantPoolEntry* next,
+  ConstantPoolEntry(Context* con,
+                    Promise* constant,
+                    ConstantPoolEntry* next,
                     Promise* callOffset);
 
   virtual int64_t value();
@@ -95,9 +101,10 @@ class ConstantPoolEntry: public Promise {
   unsigned constantPoolCount;
 };
 
-class ConstantPoolListener: public Promise::Listener {
+class ConstantPoolListener : public Promise::Listener {
  public:
-  ConstantPoolListener(vm::System* s, vm::target_uintptr_t* address,
+  ConstantPoolListener(vm::System* s,
+                       vm::target_uintptr_t* address,
                        uint8_t* returnAddress);
 
   virtual bool resolve(int64_t value, void** location);
@@ -119,7 +126,8 @@ class PoolOffset {
 
 class PoolEvent {
  public:
-  PoolEvent(PoolOffset* poolOffsetHead, PoolOffset* poolOffsetTail,
+  PoolEvent(PoolOffset* poolOffsetHead,
+            PoolOffset* poolOffsetTail,
             unsigned offset);
 
   PoolOffset* poolOffsetHead;
@@ -128,13 +136,18 @@ class PoolEvent {
   unsigned offset;
 };
 
-void appendConstantPoolEntry(Context* con, Promise* constant, Promise* callOffset);
+void appendConstantPoolEntry(Context* con,
+                             Promise* constant,
+                             Promise* callOffset);
 
-void appendPoolEvent(Context* con, MyBlock* b, unsigned offset, PoolOffset* head,
-                PoolOffset* tail);
+void appendPoolEvent(Context* con,
+                     MyBlock* b,
+                     unsigned offset,
+                     PoolOffset* head,
+                     PoolOffset* tail);
 
-} // namespace arm
-} // namespace codegen
-} // namespace avian
+}  // namespace arm
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_ASSEMBLER_ARM_PROMISE_H
+#endif  // AVIAN_CODEGEN_ASSEMBLER_ARM_PROMISE_H
diff --git a/src/codegen/target/arm/multimethod.cpp b/src/codegen/target/arm/multimethod.cpp
index cf350d0179..0ee2a642bc 100644
--- a/src/codegen/target/arm/multimethod.cpp
+++ b/src/codegen/target/arm/multimethod.cpp
@@ -21,31 +21,32 @@ namespace arm {
 using namespace util;
 
 unsigned index(ArchitectureContext*,
-      lir::BinaryOperation operation,
-      lir::OperandType operand1,
-      lir::OperandType operand2)
+               lir::BinaryOperation operation,
+               lir::OperandType operand1,
+               lir::OperandType operand2)
 {
-  return operation
-    + (lir::BinaryOperationCount * operand1)
-    + (lir::BinaryOperationCount * lir::OperandTypeCount * operand2);
+  return operation + (lir::BinaryOperationCount * operand1)
+         + (lir::BinaryOperationCount * lir::OperandTypeCount * operand2);
 }
 
 unsigned index(ArchitectureContext* con UNUSED,
-      lir::TernaryOperation operation,
-      lir::OperandType operand1)
+               lir::TernaryOperation operation,
+               lir::OperandType operand1)
 {
   assertT(con, not isBranch(operation));
 
   return operation + (lir::NonBranchTernaryOperationCount * operand1);
 }
 
-unsigned branchIndex(ArchitectureContext* con UNUSED, lir::OperandType operand1,
-            lir::OperandType operand2)
+unsigned branchIndex(ArchitectureContext* con UNUSED,
+                     lir::OperandType operand1,
+                     lir::OperandType operand2)
 {
   return operand1 + (lir::OperandTypeCount * operand2);
 }
 
-void populateTables(ArchitectureContext* con) {
+void populateTables(ArchitectureContext* con)
+{
   const lir::OperandType C = lir::ConstantOperand;
   const lir::OperandType A = lir::AddressOperand;
   const lir::OperandType R = lir::RegisterOperand;
@@ -136,6 +137,6 @@ void populateTables(ArchitectureContext* con) {
   bro[branchIndex(con, R, M)] = CAST_BRANCH(branchRM);
 }
 
-} // namespace arm
-} // namespace codegen
-} // namespace avian
+}  // namespace arm
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/target/arm/multimethod.h b/src/codegen/target/arm/multimethod.h
index 80ce2da6f0..1949bf5486 100644
--- a/src/codegen/target/arm/multimethod.h
+++ b/src/codegen/target/arm/multimethod.h
@@ -24,21 +24,22 @@ namespace codegen {
 namespace arm {
 
 unsigned index(ArchitectureContext*,
-      lir::BinaryOperation operation,
-      lir::OperandType operand1,
-      lir::OperandType operand2);
+               lir::BinaryOperation operation,
+               lir::OperandType operand1,
+               lir::OperandType operand2);
 
 unsigned index(ArchitectureContext* con UNUSED,
-      lir::TernaryOperation operation,
-      lir::OperandType operand1);
+               lir::TernaryOperation operation,
+               lir::OperandType operand1);
 
-unsigned branchIndex(ArchitectureContext* con UNUSED, lir::OperandType operand1,
-            lir::OperandType operand2);
+unsigned branchIndex(ArchitectureContext* con UNUSED,
+                     lir::OperandType operand1,
+                     lir::OperandType operand2);
 
 void populateTables(ArchitectureContext* con);
 
-} // namespace arm
-} // namespace codegen
-} // namespace avian
+}  // namespace arm
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_ASSEMBLER_ARM_MULTIMETHOD_H
+#endif  // AVIAN_CODEGEN_ASSEMBLER_ARM_MULTIMETHOD_H
diff --git a/src/codegen/target/arm/operations.cpp b/src/codegen/target/arm/operations.cpp
index cb009ca903..8afe088729 100644
--- a/src/codegen/target/arm/operations.cpp
+++ b/src/codegen/target/arm/operations.cpp
@@ -22,14 +22,27 @@ namespace arm {
 using namespace isa;
 using namespace avian::util;
 
-inline bool isOfWidth(int64_t i, int size) { return static_cast<uint64_t>(i) >> size == 0; }
+inline bool isOfWidth(int64_t i, int size)
+{
+  return static_cast<uint64_t>(i) >> size == 0;
+}
 
-inline unsigned lo8(int64_t i) { return (unsigned)(i&MASK_LO8); }
+inline unsigned lo8(int64_t i)
+{
+  return (unsigned)(i & MASK_LO8);
+}
 
-void andC(Context* con, unsigned size, lir::Constant* a,
-     lir::Register* b, lir::Register* dst);
+void andC(Context* con,
+          unsigned size,
+          lir::Constant* a,
+          lir::Register* b,
+          lir::Register* dst);
 
-void shiftLeftR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t)
+void shiftLeftR(Context* con,
+                unsigned size,
+                lir::Register* a,
+                lir::Register* b,
+                lir::Register* t)
 {
   if (size == 8) {
     int tmp1 = newTemp(con), tmp2 = newTemp(con), tmp3 = newTemp(con);
@@ -44,7 +57,9 @@ void shiftLeftR(Context* con, unsigned size, lir::Register* a, lir::Register* b,
     emit(con, SETCOND(mov(t->high, tmp1), MI));
     emit(con, SETCOND(lsl(t->high, b->low, t->high), PL));
     emit(con, lsl(t->low, b->low, tmp3));
-    freeTemp(con, tmp1); freeTemp(con, tmp2); freeTemp(con, tmp3);
+    freeTemp(con, tmp1);
+    freeTemp(con, tmp2);
+    freeTemp(con, tmp3);
   } else {
     int tmp = newTemp(con);
     ResolvedPromise maskPromise(0x1F);
@@ -56,10 +71,17 @@ void shiftLeftR(Context* con, unsigned size, lir::Register* a, lir::Register* b,
   }
 }
 
-void moveRR(Context* con, unsigned srcSize, lir::Register* src,
-       unsigned dstSize, lir::Register* dst);
+void moveRR(Context* con,
+            unsigned srcSize,
+            lir::Register* src,
+            unsigned dstSize,
+            lir::Register* dst);
 
-void shiftLeftC(Context* con, unsigned size UNUSED, lir::Constant* a, lir::Register* b, lir::Register* t)
+void shiftLeftC(Context* con,
+                unsigned size UNUSED,
+                lir::Constant* a,
+                lir::Register* b,
+                lir::Register* t)
 {
   assertT(con, size == vm::TargetBytesPerWord);
   if (getValue(a) & 0x1F) {
@@ -69,7 +91,11 @@ void shiftLeftC(Context* con, unsigned size UNUSED, lir::Constant* a, lir::Regis
   }
 }
 
-void shiftRightR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t)
+void shiftRightR(Context* con,
+                 unsigned size,
+                 lir::Register* a,
+                 lir::Register* b,
+                 lir::Register* t)
 {
   if (size == 8) {
     int tmp1 = newTemp(con), tmp2 = newTemp(con), tmp3 = newTemp(con);
@@ -84,7 +110,9 @@ void shiftRightR(Context* con, unsigned size, lir::Register* a, lir::Register* b
     emit(con, SETCOND(mov(t->low, tmp1), MI));
     emit(con, SETCOND(asr(t->low, b->high, t->low), PL));
     emit(con, asr(t->high, b->high, tmp3));
-    freeTemp(con, tmp1); freeTemp(con, tmp2); freeTemp(con, tmp3);
+    freeTemp(con, tmp1);
+    freeTemp(con, tmp2);
+    freeTemp(con, tmp3);
   } else {
     int tmp = newTemp(con);
     ResolvedPromise maskPromise(0x1F);
@@ -96,7 +124,11 @@ void shiftRightR(Context* con, unsigned size, lir::Register* a, lir::Register* b
   }
 }
 
-void shiftRightC(Context* con, unsigned size UNUSED, lir::Constant* a, lir::Register* b, lir::Register* t)
+void shiftRightC(Context* con,
+                 unsigned size UNUSED,
+                 lir::Constant* a,
+                 lir::Register* b,
+                 lir::Register* t)
 {
   assertT(con, size == vm::TargetBytesPerWord);
   if (getValue(a) & 0x1F) {
@@ -106,7 +138,11 @@ void shiftRightC(Context* con, unsigned size UNUSED, lir::Constant* a, lir::Regi
   }
 }
 
-void unsignedShiftRightR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t)
+void unsignedShiftRightR(Context* con,
+                         unsigned size,
+                         lir::Register* a,
+                         lir::Register* b,
+                         lir::Register* t)
 {
   int tmpShift = newTemp(con);
   ResolvedPromise maskPromise(size == 8 ? 0x3F : 0x1F);
@@ -123,12 +159,17 @@ void unsignedShiftRightR(Context* con, unsigned size, lir::Register* a, lir::Reg
     emit(con, lsr(tmpLo, b->high, tmpHi));
     emit(con, orr(t->low, t->low, tmpLo));
     emit(con, lsr(t->high, b->high, tmpShift));
-    freeTemp(con, tmpHi); freeTemp(con, tmpLo);
+    freeTemp(con, tmpHi);
+    freeTemp(con, tmpLo);
   }
   freeTemp(con, tmpShift);
 }
 
-void unsignedShiftRightC(Context* con, unsigned size UNUSED, lir::Constant* a, lir::Register* b, lir::Register* t)
+void unsignedShiftRightC(Context* con,
+                         unsigned size UNUSED,
+                         lir::Constant* a,
+                         lir::Register* b,
+                         lir::Register* t)
 {
   assertT(con, size == vm::TargetBytesPerWord);
   if (getValue(a) & 0x1F) {
@@ -138,14 +179,12 @@ void unsignedShiftRightC(Context* con, unsigned size UNUSED, lir::Constant* a, l
   }
 }
 
-bool
-needJump(MyBlock* b)
+bool needJump(MyBlock* b)
 {
   return b->next or b->size != (b->size & PoolOffsetMask);
 }
 
-unsigned
-padding(MyBlock* b, unsigned offset)
+unsigned padding(MyBlock* b, unsigned offset)
 {
   unsigned total = 0;
   for (PoolEvent* e = b->poolEventHead; e; e = e->next) {
@@ -181,37 +220,51 @@ void resolve(MyBlock* b)
     if (b->next == 0 or b->next->poolEventHead) {
       append = true;
     } else {
-      int32_t v = (b->start + b->size + b->next->size + vm::TargetBytesPerWord - 8)
-        - (con->poolOffsetHead->offset + con->poolOffsetHead->block->start);
+      int32_t v
+          = (b->start + b->size + b->next->size + vm::TargetBytesPerWord - 8)
+            - (con->poolOffsetHead->offset + con->poolOffsetHead->block->start);
 
       append = (v != (v & PoolOffsetMask));
 
       if (DebugPool) {
         fprintf(stderr,
                 "current %p %d %d next %p %d %d\n",
-                b, b->start, b->size, b->next, b->start + b->size,
+                b,
+                b->start,
+                b->size,
+                b->next,
+                b->start + b->size,
                 b->next->size);
         fprintf(stderr,
                 "offset %p %d is of distance %d to next block; append? %d\n",
-                con->poolOffsetHead, con->poolOffsetHead->offset, v, append);
+                con->poolOffsetHead,
+                con->poolOffsetHead->offset,
+                v,
+                append);
       }
     }
 
     if (append) {
 #ifndef NDEBUG
-      int32_t v = (b->start + b->size - 8)
-        - (con->poolOffsetHead->offset + con->poolOffsetHead->block->start);
-      
-      expect(con, v == (v & PoolOffsetMask));
-#endif // not NDEBUG
+      int32_t v
+          = (b->start + b->size - 8)
+            - (con->poolOffsetHead->offset + con->poolOffsetHead->block->start);
 
-      appendPoolEvent(con, b, b->size, con->poolOffsetHead, con->poolOffsetTail);
+      expect(con, v == (v & PoolOffsetMask));
+#endif  // not NDEBUG
+
+      appendPoolEvent(
+          con, b, b->size, con->poolOffsetHead, con->poolOffsetTail);
 
       if (DebugPool) {
         for (PoolOffset* o = con->poolOffsetHead; o; o = o->next) {
           fprintf(stderr,
                   "include %p %d in pool event %p at offset %d in block %p\n",
-                  o, o->offset, b->poolEventTail, b->size, b);
+                  o,
+                  o->offset,
+                  b->poolEventTail,
+                  b->size,
+                  b);
         }
       }
 
@@ -227,8 +280,11 @@ void jumpR(Context* con, unsigned size UNUSED, lir::Register* target)
   emit(con, bx(target->low));
 }
 
-void swapRR(Context* con, unsigned aSize, lir::Register* a,
-       unsigned bSize, lir::Register* b)
+void swapRR(Context* con,
+            unsigned aSize,
+            lir::Register* a,
+            unsigned bSize,
+            lir::Register* b)
 {
   assertT(con, aSize == vm::TargetBytesPerWord);
   assertT(con, bSize == vm::TargetBytesPerWord);
@@ -240,23 +296,32 @@ void swapRR(Context* con, unsigned aSize, lir::Register* a,
   con->client->releaseTemporary(tmp.low);
 }
 
-void moveRR(Context* con, unsigned srcSize, lir::Register* src,
-       unsigned dstSize, lir::Register* dst)
+void moveRR(Context* con,
+            unsigned srcSize,
+            lir::Register* src,
+            unsigned dstSize,
+            lir::Register* dst)
 {
   bool srcIsFpr = isFpr(src);
   bool dstIsFpr = isFpr(dst);
-  if (srcIsFpr || dstIsFpr) {   // FPR(s) involved
+  if (srcIsFpr || dstIsFpr) {  // FPR(s) involved
     assertT(con, srcSize == dstSize);
     const bool dprec = srcSize == 8;
-    if (srcIsFpr && dstIsFpr) { // FPR to FPR
-      if (dprec) emit(con, fcpyd(fpr64(dst), fpr64(src))); // double
-      else       emit(con, fcpys(fpr32(dst), fpr32(src))); // single
-    } else if (srcIsFpr) {      // FPR to GPR
-      if (dprec) emit(con, fmrrd(dst->low, dst->high, fpr64(src)));
-      else       emit(con, fmrs(dst->low, fpr32(src)));
-    } else {                    // GPR to FPR
-      if (dprec) emit(con, fmdrr(fpr64(dst->low), src->low, src->high));
-      else       emit(con, fmsr(fpr32(dst), src->low));
+    if (srcIsFpr && dstIsFpr) {  // FPR to FPR
+      if (dprec)
+        emit(con, fcpyd(fpr64(dst), fpr64(src)));  // double
+      else
+        emit(con, fcpys(fpr32(dst), fpr32(src)));  // single
+    } else if (srcIsFpr) {                         // FPR to GPR
+      if (dprec)
+        emit(con, fmrrd(dst->low, dst->high, fpr64(src)));
+      else
+        emit(con, fmrs(dst->low, fpr32(src)));
+    } else {  // GPR to FPR
+      if (dprec)
+        emit(con, fmdrr(fpr64(dst->low), src->low, src->high));
+      else
+        emit(con, fmsr(fpr32(dst), src->low));
     }
     return;
   }
@@ -297,12 +362,16 @@ void moveRR(Context* con, unsigned srcSize, lir::Register* src,
     }
     break;
 
-  default: abort(con);
+  default:
+    abort(con);
   }
 }
 
-void moveZRR(Context* con, unsigned srcSize, lir::Register* src,
-        unsigned, lir::Register* dst)
+void moveZRR(Context* con,
+             unsigned srcSize,
+             lir::Register* src,
+             unsigned,
+             lir::Register* dst)
 {
   switch (srcSize) {
   case 2:
@@ -310,46 +379,60 @@ void moveZRR(Context* con, unsigned srcSize, lir::Register* src,
     emit(con, lsri(dst->low, dst->low, 16));
     break;
 
-  default: abort(con);
+  default:
+    abort(con);
   }
 }
 
-void moveCR(Context* con, unsigned size, lir::Constant* src,
-            unsigned, lir::Register* dst);
+void moveCR(Context* con,
+            unsigned size,
+            lir::Constant* src,
+            unsigned,
+            lir::Register* dst);
 
-void moveCR2(Context* con, unsigned size, lir::Constant* src,
-        lir::Register* dst, Promise* callOffset)
+void moveCR2(Context* con,
+             unsigned size,
+             lir::Constant* src,
+             lir::Register* dst,
+             Promise* callOffset)
 {
-  if (isFpr(dst)) { // floating-point
-    lir::Register tmp = size > 4 ? makeTemp64(con) :
-                                         makeTemp(con);
+  if (isFpr(dst)) {  // floating-point
+    lir::Register tmp = size > 4 ? makeTemp64(con) : makeTemp(con);
     moveCR(con, size, src, size, &tmp);
     moveRR(con, size, &tmp, size, dst);
     freeTemp(con, tmp);
-  } else if (size > 4) { 
+  } else if (size > 4) {
     uint64_t value = (uint64_t)src->value->value();
     ResolvedPromise loBits(value & MASK_LO32);
     lir::Constant srcLo(&loBits);
-    ResolvedPromise hiBits(value >> 32); 
+    ResolvedPromise hiBits(value >> 32);
     lir::Constant srcHi(&hiBits);
     lir::Register dstHi(dst->high);
     moveCR(con, 4, &srcLo, 4, dst);
     moveCR(con, 4, &srcHi, 4, &dstHi);
   } else if (src->value->resolved() and isOfWidth(getValue(src), 8)) {
-    emit(con, movi(dst->low, lo8(getValue(src)))); // fits in immediate
+    emit(con, movi(dst->low, lo8(getValue(src))));  // fits in immediate
   } else {
     appendConstantPoolEntry(con, src->value, callOffset);
-    emit(con, ldri(dst->low, ProgramCounter, 0)); // load 32 bits
+    emit(con, ldri(dst->low, ProgramCounter, 0));  // load 32 bits
   }
 }
 
-void moveCR(Context* con, unsigned size, lir::Constant* src,
-       unsigned, lir::Register* dst)
+void moveCR(Context* con,
+            unsigned size,
+            lir::Constant* src,
+            unsigned,
+            lir::Register* dst)
 {
   moveCR2(con, size, src, dst, 0);
 }
 
-void addR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t) {
+void addR(Context* con,
+          unsigned size,
+          lir::Register* a,
+          lir::Register* b,
+          lir::Register* t)
+{
   if (size == 8) {
     emit(con, SETS(add(t->low, a->low, b->low)));
     emit(con, adc(t->high, a->high, b->high));
@@ -358,7 +441,12 @@ void addR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::
   }
 }
 
-void subR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t) {
+void subR(Context* con,
+          unsigned size,
+          lir::Register* a,
+          lir::Register* b,
+          lir::Register* t)
+{
   if (size == 8) {
     emit(con, SETS(rsb(t->low, a->low, b->low)));
     emit(con, rsc(t->high, a->high, b->high));
@@ -367,8 +455,11 @@ void subR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::
   }
 }
 
-void addC(Context* con, unsigned size, lir::Constant* a,
-     lir::Register* b, lir::Register* dst)
+void addC(Context* con,
+          unsigned size,
+          lir::Constant* a,
+          lir::Register* b,
+          lir::Register* dst)
 {
   assertT(con, size == vm::TargetBytesPerWord);
 
@@ -387,8 +478,11 @@ void addC(Context* con, unsigned size, lir::Constant* a,
   }
 }
 
-void subC(Context* con, unsigned size, lir::Constant* a,
-     lir::Register* b, lir::Register* dst)
+void subC(Context* con,
+          unsigned size,
+          lir::Constant* a,
+          lir::Register* b,
+          lir::Register* dst)
 {
   assertT(con, size == vm::TargetBytesPerWord);
 
@@ -407,11 +501,18 @@ void subC(Context* con, unsigned size, lir::Constant* a,
   }
 }
 
-void multiplyR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t) {
+void multiplyR(Context* con,
+               unsigned size,
+               lir::Register* a,
+               lir::Register* b,
+               lir::Register* t)
+{
   if (size == 8) {
     bool useTemporaries = b->low == t->low;
-    int tmpLow  = useTemporaries ? con->client->acquireTemporary(GPR_MASK) : t->low;
-    int tmpHigh = useTemporaries ? con->client->acquireTemporary(GPR_MASK) : t->high;
+    int tmpLow = useTemporaries ? con->client->acquireTemporary(GPR_MASK)
+                                : t->low;
+    int tmpHigh = useTemporaries ? con->client->acquireTemporary(GPR_MASK)
+                                 : t->high;
 
     emit(con, umull(tmpLow, tmpHigh, a->low, b->low));
     emit(con, mla(tmpHigh, a->low, b->high, tmpHigh));
@@ -428,7 +529,12 @@ void multiplyR(Context* con, unsigned size, lir::Register* a, lir::Register* b,
   }
 }
 
-void floatAbsoluteRR(Context* con, unsigned size, lir::Register* a, unsigned, lir::Register* b) {
+void floatAbsoluteRR(Context* con,
+                     unsigned size,
+                     lir::Register* a,
+                     unsigned,
+                     lir::Register* b)
+{
   if (size == 8) {
     emit(con, fabsd(fpr64(b), fpr64(a)));
   } else {
@@ -436,7 +542,12 @@ void floatAbsoluteRR(Context* con, unsigned size, lir::Register* a, unsigned, li
   }
 }
 
-void floatNegateRR(Context* con, unsigned size, lir::Register* a, unsigned, lir::Register* b) {
+void floatNegateRR(Context* con,
+                   unsigned size,
+                   lir::Register* a,
+                   unsigned,
+                   lir::Register* b)
+{
   if (size == 8) {
     emit(con, fnegd(fpr64(b), fpr64(a)));
   } else {
@@ -444,7 +555,12 @@ void floatNegateRR(Context* con, unsigned size, lir::Register* a, unsigned, lir:
   }
 }
 
-void float2FloatRR(Context* con, unsigned size, lir::Register* a, unsigned, lir::Register* b) {
+void float2FloatRR(Context* con,
+                   unsigned size,
+                   lir::Register* a,
+                   unsigned,
+                   lir::Register* b)
+{
   if (size == 8) {
     emit(con, fcvtsd(fpr32(b), fpr64(a)));
   } else {
@@ -452,28 +568,43 @@ void float2FloatRR(Context* con, unsigned size, lir::Register* a, unsigned, lir:
   }
 }
 
-void float2IntRR(Context* con, unsigned size, lir::Register* a, unsigned, lir::Register* b) {
+void float2IntRR(Context* con,
+                 unsigned size,
+                 lir::Register* a,
+                 unsigned,
+                 lir::Register* b)
+{
   int tmp = newTemp(con, FPR_MASK);
   int ftmp = fpr32(tmp);
-  if (size == 8) { // double to int
+  if (size == 8) {  // double to int
     emit(con, ftosizd(ftmp, fpr64(a)));
-  } else {         // float to int
+  } else {  // float to int
     emit(con, ftosizs(ftmp, fpr32(a)));
-  }                // else thunked
+  }  // else thunked
   emit(con, fmrs(b->low, ftmp));
   freeTemp(con, tmp);
 }
 
-void int2FloatRR(Context* con, unsigned, lir::Register* a, unsigned size, lir::Register* b) {
+void int2FloatRR(Context* con,
+                 unsigned,
+                 lir::Register* a,
+                 unsigned size,
+                 lir::Register* b)
+{
   emit(con, fmsr(fpr32(b), a->low));
-  if (size == 8) { // int to double
+  if (size == 8) {  // int to double
     emit(con, fsitod(fpr64(b), fpr32(b)));
-  } else {         // int to float
+  } else {  // int to float
     emit(con, fsitos(fpr32(b), fpr32(b)));
-  }                // else thunked
+  }  // else thunked
 }
 
-void floatSqrtRR(Context* con, unsigned size, lir::Register* a, unsigned, lir::Register* b) {
+void floatSqrtRR(Context* con,
+                 unsigned size,
+                 lir::Register* a,
+                 unsigned,
+                 lir::Register* b)
+{
   if (size == 8) {
     emit(con, fsqrtd(fpr64(b), fpr64(a)));
   } else {
@@ -481,7 +612,12 @@ void floatSqrtRR(Context* con, unsigned size, lir::Register* a, unsigned, lir::R
   }
 }
 
-void floatAddR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t) {
+void floatAddR(Context* con,
+               unsigned size,
+               lir::Register* a,
+               lir::Register* b,
+               lir::Register* t)
+{
   if (size == 8) {
     emit(con, faddd(fpr64(t), fpr64(a), fpr64(b)));
   } else {
@@ -489,7 +625,12 @@ void floatAddR(Context* con, unsigned size, lir::Register* a, lir::Register* b,
   }
 }
 
-void floatSubtractR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t) {
+void floatSubtractR(Context* con,
+                    unsigned size,
+                    lir::Register* a,
+                    lir::Register* b,
+                    lir::Register* t)
+{
   if (size == 8) {
     emit(con, fsubd(fpr64(t), fpr64(b), fpr64(a)));
   } else {
@@ -497,7 +638,12 @@ void floatSubtractR(Context* con, unsigned size, lir::Register* a, lir::Register
   }
 }
 
-void floatMultiplyR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t) {
+void floatMultiplyR(Context* con,
+                    unsigned size,
+                    lir::Register* a,
+                    lir::Register* b,
+                    lir::Register* t)
+{
   if (size == 8) {
     emit(con, fmuld(fpr64(t), fpr64(a), fpr64(b)));
   } else {
@@ -505,21 +651,30 @@ void floatMultiplyR(Context* con, unsigned size, lir::Register* a, lir::Register
   }
 }
 
-void floatDivideR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t) {
-  if (size == 8) { 
+void floatDivideR(Context* con,
+                  unsigned size,
+                  lir::Register* a,
+                  lir::Register* b,
+                  lir::Register* t)
+{
+  if (size == 8) {
     emit(con, fdivd(fpr64(t), fpr64(b), fpr64(a)));
   } else {
     emit(con, fdivs(fpr32(t), fpr32(b), fpr32(a)));
   }
 }
 
-int normalize(Context* con, int offset, int index, unsigned scale, 
-          bool* preserveIndex, bool* release)
+int normalize(Context* con,
+              int offset,
+              int index,
+              unsigned scale,
+              bool* preserveIndex,
+              bool* release)
 {
   if (offset != 0 or scale != 1) {
-    lir::Register normalizedIndex
-      (*preserveIndex ? con->client->acquireTemporary(GPR_MASK) : index);
-    
+    lir::Register normalizedIndex(
+        *preserveIndex ? con->client->acquireTemporary(GPR_MASK) : index);
+
     if (*preserveIndex) {
       *release = true;
       *preserveIndex = false;
@@ -534,9 +689,12 @@ int normalize(Context* con, int offset, int index, unsigned scale,
 
       ResolvedPromise scalePromise(log(scale));
       lir::Constant scaleConstant(&scalePromise);
-      
-      shiftLeftC(con, vm::TargetBytesPerWord, &scaleConstant,
-                 &unscaledIndex, &normalizedIndex);
+
+      shiftLeftC(con,
+                 vm::TargetBytesPerWord,
+                 &scaleConstant,
+                 &unscaledIndex,
+                 &normalizedIndex);
 
       scaled = normalizedIndex.low;
     } else {
@@ -550,8 +708,16 @@ int normalize(Context* con, int offset, int index, unsigned scale,
       lir::Constant offsetConstant(&offsetPromise);
 
       lir::Register tmp(con->client->acquireTemporary(GPR_MASK));
-      moveCR(con, vm::TargetBytesPerWord, &offsetConstant, vm::TargetBytesPerWord, &tmp);
-      addR(con, vm::TargetBytesPerWord, &tmp, &untranslatedIndex, &normalizedIndex);
+      moveCR(con,
+             vm::TargetBytesPerWord,
+             &offsetConstant,
+             vm::TargetBytesPerWord,
+             &tmp);
+      addR(con,
+           vm::TargetBytesPerWord,
+           &tmp,
+           &untranslatedIndex,
+           &normalizedIndex);
       con->client->releaseTemporary(tmp.low);
     }
 
@@ -562,15 +728,21 @@ int normalize(Context* con, int offset, int index, unsigned scale,
   }
 }
 
-void store(Context* con, unsigned size, lir::Register* src,
-      int base, int offset, int index, unsigned scale, bool preserveIndex)
+void store(Context* con,
+           unsigned size,
+           lir::Register* src,
+           int base,
+           int offset,
+           int index,
+           unsigned scale,
+           bool preserveIndex)
 {
   if (index != lir::NoRegister) {
     bool release;
-    int normalized = normalize
-      (con, offset, index, scale, &preserveIndex, &release);
+    int normalized
+        = normalize(con, offset, index, scale, &preserveIndex, &release);
 
-    if (!isFpr(src)) { // GPR store
+    if (!isFpr(src)) {  // GPR store
       switch (size) {
       case 1:
         emit(con, strb(src->low, base, normalized));
@@ -584,33 +756,34 @@ void store(Context* con, unsigned size, lir::Register* src,
         emit(con, str(src->low, base, normalized));
         break;
 
-      case 8: { // split into 2 32-bit stores
+      case 8: {  // split into 2 32-bit stores
         lir::Register srcHigh(src->high);
         store(con, 4, &srcHigh, base, 0, normalized, 1, preserveIndex);
         store(con, 4, src, base, 4, normalized, 1, preserveIndex);
       } break;
 
-      default: abort(con);
+      default:
+        abort(con);
       }
-    } else { // FPR store
-      lir::Register base_(base),
-                          normalized_(normalized),
-                          absAddr = makeTemp(con);
+    } else {  // FPR store
+      lir::Register base_(base), normalized_(normalized),
+          absAddr = makeTemp(con);
       // FPR stores have only bases, so we must add the index
       addR(con, vm::TargetBytesPerWord, &base_, &normalized_, &absAddr);
       // double-precision
-      if (size == 8) emit(con, fstd(fpr64(src), absAddr.low));
+      if (size == 8)
+        emit(con, fstd(fpr64(src), absAddr.low));
       // single-precision
-      else           emit(con, fsts(fpr32(src), absAddr.low));
+      else
+        emit(con, fsts(fpr32(src), absAddr.low));
       freeTemp(con, absAddr);
     }
 
-    if (release) con->client->releaseTemporary(normalized);
-  } else if (size == 8
-             or abs(offset) == (abs(offset) & 0xFF)
-             or (size != 2 and abs(offset) == (abs(offset) & 0xFFF)))
-  {
-    if (!isFpr(src)) { // GPR store
+    if (release)
+      con->client->releaseTemporary(normalized);
+  } else if (size == 8 or abs(offset) == (abs(offset) & 0xFF)
+             or (size != 2 and abs(offset) == (abs(offset) & 0xFFF))) {
+    if (!isFpr(src)) {  // GPR store
       switch (size) {
       case 1:
         emit(con, strbi(src->low, base, offset));
@@ -624,51 +797,68 @@ void store(Context* con, unsigned size, lir::Register* src,
         emit(con, stri(src->low, base, offset));
         break;
 
-      case 8: { // split into 2 32-bit stores
+      case 8: {  // split into 2 32-bit stores
         lir::Register srcHigh(src->high);
         store(con, 4, &srcHigh, base, offset, lir::NoRegister, 1, false);
         store(con, 4, src, base, offset + 4, lir::NoRegister, 1, false);
       } break;
 
-      default: abort(con);
+      default:
+        abort(con);
       }
-    } else { // FPR store
+    } else {  // FPR store
       // double-precision
-      if (size == 8) emit(con, fstd(fpr64(src), base, offset));
+      if (size == 8)
+        emit(con, fstd(fpr64(src), base, offset));
       // single-precision
-      else           emit(con, fsts(fpr32(src), base, offset));
+      else
+        emit(con, fsts(fpr32(src), base, offset));
     }
   } else {
     lir::Register tmp(con->client->acquireTemporary(GPR_MASK));
     ResolvedPromise offsetPromise(offset);
     lir::Constant offsetConstant(&offsetPromise);
-    moveCR(con, vm::TargetBytesPerWord, &offsetConstant,
-           vm::TargetBytesPerWord, &tmp);
-    
+    moveCR(con,
+           vm::TargetBytesPerWord,
+           &offsetConstant,
+           vm::TargetBytesPerWord,
+           &tmp);
+
     store(con, size, src, base, 0, tmp.low, 1, false);
 
     con->client->releaseTemporary(tmp.low);
   }
 }
 
-void moveRM(Context* con, unsigned srcSize, lir::Register* src,
-       unsigned dstSize UNUSED, lir::Memory* dst)
+void moveRM(Context* con,
+            unsigned srcSize,
+            lir::Register* src,
+            unsigned dstSize UNUSED,
+            lir::Memory* dst)
 {
   assertT(con, srcSize == dstSize);
 
-  store(con, srcSize, src, dst->base, dst->offset, dst->index, dst->scale, true);
+  store(
+      con, srcSize, src, dst->base, dst->offset, dst->index, dst->scale, true);
 }
 
-void load(Context* con, unsigned srcSize, int base, int offset, int index,
-     unsigned scale, unsigned dstSize, lir::Register* dst,
-     bool preserveIndex, bool signExtend)
+void load(Context* con,
+          unsigned srcSize,
+          int base,
+          int offset,
+          int index,
+          unsigned scale,
+          unsigned dstSize,
+          lir::Register* dst,
+          bool preserveIndex,
+          bool signExtend)
 {
   if (index != lir::NoRegister) {
     bool release;
-    int normalized = normalize
-      (con, offset, index, scale, &preserveIndex, &release);
+    int normalized
+        = normalize(con, offset, index, scale, &preserveIndex, &release);
 
-    if (!isFpr(dst)) { // GPR load
+    if (!isFpr(dst)) {  // GPR load
       switch (srcSize) {
       case 1:
         if (signExtend) {
@@ -689,43 +879,50 @@ void load(Context* con, unsigned srcSize, int base, int offset, int index,
       case 4:
       case 8: {
         if (srcSize == 4 and dstSize == 8) {
-          load(con, 4, base, 0, normalized, 1, 4, dst, preserveIndex,
-               false);
+          load(con, 4, base, 0, normalized, 1, 4, dst, preserveIndex, false);
           moveRR(con, 4, dst, 8, dst);
         } else if (srcSize == 8 and dstSize == 8) {
           lir::Register dstHigh(dst->high);
-          load(con, 4, base, 0, normalized, 1, 4, &dstHigh,
-              preserveIndex, false);
-          load(con, 4, base, 4, normalized, 1, 4, dst, preserveIndex,
+          load(con,
+               4,
+               base,
+               0,
+               normalized,
+               1,
+               4,
+               &dstHigh,
+               preserveIndex,
                false);
+          load(con, 4, base, 4, normalized, 1, 4, dst, preserveIndex, false);
         } else {
           emit(con, ldr(dst->low, base, normalized));
         }
       } break;
 
-      default: abort(con);
+      default:
+        abort(con);
       }
-    } else { // FPR load
-      lir::Register base_(base),
-                          normalized_(normalized),
-                          absAddr = makeTemp(con);
+    } else {  // FPR load
+      lir::Register base_(base), normalized_(normalized),
+          absAddr = makeTemp(con);
       // VFP loads only have bases, so we must add the index
       addR(con, vm::TargetBytesPerWord, &base_, &normalized_, &absAddr);
       // double-precision
-      if (srcSize == 8) emit(con, fldd(fpr64(dst), absAddr.low));
+      if (srcSize == 8)
+        emit(con, fldd(fpr64(dst), absAddr.low));
       // single-precision
-      else              emit(con, flds(fpr32(dst), absAddr.low));
+      else
+        emit(con, flds(fpr32(dst), absAddr.low));
       freeTemp(con, absAddr);
     }
 
-    if (release) con->client->releaseTemporary(normalized);
+    if (release)
+      con->client->releaseTemporary(normalized);
   } else if ((srcSize == 8 and dstSize == 8)
              or abs(offset) == (abs(offset) & 0xFF)
-             or (srcSize != 2
-                 and (srcSize != 1 or not signExtend)
-                 and abs(offset) == (abs(offset) & 0xFFF)))
-  {
-    if (!isFpr(dst)) { // GPR load
+             or (srcSize != 2 and (srcSize != 1 or not signExtend)
+                 and abs(offset) == (abs(offset) & 0xFFF))) {
+    if (!isFpr(dst)) {  // GPR load
       switch (srcSize) {
       case 1:
         if (signExtend) {
@@ -750,60 +947,110 @@ void load(Context* con, unsigned srcSize, int base, int offset, int index,
       case 8: {
         if (dstSize == 8) {
           lir::Register dstHigh(dst->high);
-          load(con, 4, base, offset, lir::NoRegister, 1, 4, &dstHigh, false,
+          load(con,
+               4,
+               base,
+               offset,
+               lir::NoRegister,
+               1,
+               4,
+               &dstHigh,
+               false,
                false);
-          load(con, 4, base, offset + 4, lir::NoRegister, 1, 4, dst, false,
+          load(con,
+               4,
+               base,
+               offset + 4,
+               lir::NoRegister,
+               1,
+               4,
+               dst,
+               false,
                false);
         } else {
           emit(con, ldri(dst->low, base, offset));
         }
       } break;
 
-      default: abort(con);
+      default:
+        abort(con);
       }
-    } else { // FPR load
+    } else {  // FPR load
       // double-precision
-      if (srcSize == 8) emit(con, fldd(fpr64(dst), base, offset));
+      if (srcSize == 8)
+        emit(con, fldd(fpr64(dst), base, offset));
       // single-precision
-      else              emit(con, flds(fpr32(dst), base, offset));
+      else
+        emit(con, flds(fpr32(dst), base, offset));
     }
   } else {
     lir::Register tmp(con->client->acquireTemporary(GPR_MASK));
     ResolvedPromise offsetPromise(offset);
     lir::Constant offsetConstant(&offsetPromise);
-    moveCR(con, vm::TargetBytesPerWord, &offsetConstant, vm::TargetBytesPerWord,
+    moveCR(con,
+           vm::TargetBytesPerWord,
+           &offsetConstant,
+           vm::TargetBytesPerWord,
            &tmp);
-    
-    load(con, srcSize, base, 0, tmp.low, 1, dstSize, dst, false,
-         signExtend);
+
+    load(con, srcSize, base, 0, tmp.low, 1, dstSize, dst, false, signExtend);
 
     con->client->releaseTemporary(tmp.low);
   }
 }
 
-void moveMR(Context* con, unsigned srcSize, lir::Memory* src,
-       unsigned dstSize, lir::Register* dst)
+void moveMR(Context* con,
+            unsigned srcSize,
+            lir::Memory* src,
+            unsigned dstSize,
+            lir::Register* dst)
 {
-  load(con, srcSize, src->base, src->offset, src->index, src->scale,
-       dstSize, dst, true, true);
+  load(con,
+       srcSize,
+       src->base,
+       src->offset,
+       src->index,
+       src->scale,
+       dstSize,
+       dst,
+       true,
+       true);
 }
 
-void moveZMR(Context* con, unsigned srcSize, lir::Memory* src,
-        unsigned dstSize, lir::Register* dst)
+void moveZMR(Context* con,
+             unsigned srcSize,
+             lir::Memory* src,
+             unsigned dstSize,
+             lir::Register* dst)
 {
-  load(con, srcSize, src->base, src->offset, src->index, src->scale,
-       dstSize, dst, true, false);
+  load(con,
+       srcSize,
+       src->base,
+       src->offset,
+       src->index,
+       src->scale,
+       dstSize,
+       dst,
+       true,
+       false);
 }
 
-void andR(Context* con, unsigned size, lir::Register* a,
-     lir::Register* b, lir::Register* dst)
+void andR(Context* con,
+          unsigned size,
+          lir::Register* a,
+          lir::Register* b,
+          lir::Register* dst)
 {
-  if (size == 8) emit(con, and_(dst->high, a->high, b->high));
+  if (size == 8)
+    emit(con, and_(dst->high, a->high, b->high));
   emit(con, and_(dst->low, a->low, b->low));
 }
 
-void andC(Context* con, unsigned size, lir::Constant* a,
-     lir::Register* b, lir::Register* dst)
+void andC(Context* con,
+          unsigned size,
+          lir::Constant* a,
+          lir::Register* b,
+          lir::Register* dst)
 {
   int64_t v = a->value->value();
 
@@ -838,7 +1085,7 @@ void andC(Context* con, unsigned size, lir::Constant* a,
 
         moveCR(con, 4, a, 4, &tmp);
         andR(con, 4, b, &tmp, dst);
-        
+
         if (useTemporary) {
           con->client->releaseTemporary(tmp.low);
         }
@@ -849,22 +1096,33 @@ void andC(Context* con, unsigned size, lir::Constant* a,
   }
 }
 
-void orR(Context* con, unsigned size, lir::Register* a,
-    lir::Register* b, lir::Register* dst)
+void orR(Context* con,
+         unsigned size,
+         lir::Register* a,
+         lir::Register* b,
+         lir::Register* dst)
 {
-  if (size == 8) emit(con, orr(dst->high, a->high, b->high));
+  if (size == 8)
+    emit(con, orr(dst->high, a->high, b->high));
   emit(con, orr(dst->low, a->low, b->low));
 }
 
-void xorR(Context* con, unsigned size, lir::Register* a,
-     lir::Register* b, lir::Register* dst)
+void xorR(Context* con,
+          unsigned size,
+          lir::Register* a,
+          lir::Register* b,
+          lir::Register* dst)
 {
-  if (size == 8) emit(con, eor(dst->high, a->high, b->high));
+  if (size == 8)
+    emit(con, eor(dst->high, a->high, b->high));
   emit(con, eor(dst->low, a->low, b->low));
 }
 
-void moveAR2(Context* con, unsigned srcSize, lir::Address* src,
-       unsigned dstSize, lir::Register* dst)
+void moveAR2(Context* con,
+             unsigned srcSize,
+             lir::Address* src,
+             unsigned dstSize,
+             lir::Register* dst)
 {
   assertT(con, srcSize == 4 and dstSize == 4);
 
@@ -875,36 +1133,46 @@ void moveAR2(Context* con, unsigned srcSize, lir::Address* src,
   moveMR(con, dstSize, &memory, dstSize, dst);
 }
 
-void moveAR(Context* con, unsigned srcSize, lir::Address* src,
-       unsigned dstSize, lir::Register* dst)
+void moveAR(Context* con,
+            unsigned srcSize,
+            lir::Address* src,
+            unsigned dstSize,
+            lir::Register* dst)
 {
   moveAR2(con, srcSize, src, dstSize, dst);
 }
 
-void compareRR(Context* con, unsigned aSize, lir::Register* a,
-          unsigned bSize UNUSED, lir::Register* b)
+void compareRR(Context* con,
+               unsigned aSize,
+               lir::Register* a,
+               unsigned bSize UNUSED,
+               lir::Register* b)
 {
   assertT(con, !(isFpr(a) ^ isFpr(b)));  // regs must be of the same type
 
-  if (!isFpr(a)) { // GPR compare
+  if (!isFpr(a)) {  // GPR compare
     assertT(con, aSize == 4 && bSize == 4);
     /**/  // assertT(con, b->low != a->low);
     emit(con, cmp(b->low, a->low));
-  } else {         // FPR compare
+  } else {  // FPR compare
     assertT(con, aSize == bSize);
-    if (aSize == 8) emit(con, fcmpd(fpr64(b), fpr64(a))); // double
-    else            emit(con, fcmps(fpr32(b), fpr32(a))); // single
+    if (aSize == 8)
+      emit(con, fcmpd(fpr64(b), fpr64(a)));  // double
+    else
+      emit(con, fcmps(fpr32(b), fpr32(a)));  // single
     emit(con, fmstat());
   }
 }
 
-void compareCR(Context* con, unsigned aSize, lir::Constant* a,
-          unsigned bSize, lir::Register* b)
+void compareCR(Context* con,
+               unsigned aSize,
+               lir::Constant* a,
+               unsigned bSize,
+               lir::Register* b)
 {
   assertT(con, aSize == 4 and bSize == 4);
 
-  if (!isFpr(b) && a->value->resolved() &&
-      isOfWidth(a->value->value(), 8)) {
+  if (!isFpr(b) && a->value->resolved() && isOfWidth(a->value->value(), 8)) {
     emit(con, cmpi(b->low, a->value->value()));
   } else {
     lir::Register tmp(con->client->acquireTemporary(GPR_MASK));
@@ -914,8 +1182,11 @@ void compareCR(Context* con, unsigned aSize, lir::Constant* a,
   }
 }
 
-void compareCM(Context* con, unsigned aSize, lir::Constant* a,
-          unsigned bSize, lir::Memory* b)
+void compareCM(Context* con,
+               unsigned aSize,
+               lir::Constant* a,
+               unsigned bSize,
+               lir::Memory* b)
 {
   assertT(con, aSize == 4 and bSize == 4);
 
@@ -925,8 +1196,11 @@ void compareCM(Context* con, unsigned aSize, lir::Constant* a,
   con->client->releaseTemporary(tmp.low);
 }
 
-void compareRM(Context* con, unsigned aSize, lir::Register* a,
-          unsigned bSize, lir::Memory* b)
+void compareRM(Context* con,
+               unsigned aSize,
+               lir::Register* a,
+               unsigned bSize,
+               lir::Memory* b)
 {
   assertT(con, aSize == 4 and bSize == 4);
 
@@ -936,8 +1210,7 @@ void compareRM(Context* con, unsigned aSize, lir::Register* a,
   con->client->releaseTemporary(tmp.low);
 }
 
-int32_t
-branch(Context* con, lir::TernaryOperation op)
+int32_t branch(Context* con, lir::TernaryOperation op)
 {
   switch (op) {
   case lir::JumpIfEqual:
@@ -971,7 +1244,7 @@ branch(Context* con, lir::TernaryOperation op)
 
   case lir::JumpIfFloatGreaterOrEqualOrUnordered:
     return bpl(0);
- 
+
   default:
     abort(con);
   }
@@ -988,16 +1261,20 @@ void branch(Context* con, lir::TernaryOperation op, lir::Constant* target)
   conditional(con, branch(con, op), target);
 }
 
-void branchLong(Context* con, lir::TernaryOperation op, lir::Operand* al,
-           lir::Operand* ah, lir::Operand* bl,
-           lir::Operand* bh, lir::Constant* target,
-           BinaryOperationType compareSigned,
-           BinaryOperationType compareUnsigned)
+void branchLong(Context* con,
+                lir::TernaryOperation op,
+                lir::Operand* al,
+                lir::Operand* ah,
+                lir::Operand* bl,
+                lir::Operand* bh,
+                lir::Constant* target,
+                BinaryOperationType compareSigned,
+                BinaryOperationType compareUnsigned)
 {
   compareSigned(con, 4, ah, 4, bh);
 
   unsigned next = 0;
-  
+
   switch (op) {
   case lir::JumpIfEqual:
   case lir::JumpIfFloatEqual:
@@ -1072,25 +1349,31 @@ void branchLong(Context* con, lir::TernaryOperation op, lir::Operand* al,
   }
 }
 
-void branchRR(Context* con, lir::TernaryOperation op, unsigned size,
-         lir::Register* a, lir::Register* b,
-         lir::Constant* target)
+void branchRR(Context* con,
+              lir::TernaryOperation op,
+              unsigned size,
+              lir::Register* a,
+              lir::Register* b,
+              lir::Constant* target)
 {
   if (!isFpr(a) && size > vm::TargetBytesPerWord) {
     lir::Register ah(a->high);
     lir::Register bh(b->high);
 
-    branchLong(con, op, a, &ah, b, &bh, target, CAST2(compareRR),
-               CAST2(compareRR));
+    branchLong(
+        con, op, a, &ah, b, &bh, target, CAST2(compareRR), CAST2(compareRR));
   } else {
     compareRR(con, size, a, size, b);
     branch(con, op, target);
   }
 }
 
-void branchCR(Context* con, lir::TernaryOperation op, unsigned size,
-         lir::Constant* a, lir::Register* b,
-         lir::Constant* target)
+void branchCR(Context* con,
+              lir::TernaryOperation op,
+              unsigned size,
+              lir::Constant* a,
+              lir::Register* b,
+              lir::Constant* target)
 {
   assertT(con, !isFloatBranch(op));
 
@@ -1105,17 +1388,20 @@ void branchCR(Context* con, lir::TernaryOperation op, unsigned size,
 
     lir::Register bh(b->high);
 
-    branchLong(con, op, &al, &ah, b, &bh, target, CAST2(compareCR),
-               CAST2(compareCR));
+    branchLong(
+        con, op, &al, &ah, b, &bh, target, CAST2(compareCR), CAST2(compareCR));
   } else {
     compareCR(con, size, a, size, b);
     branch(con, op, target);
   }
 }
 
-void branchRM(Context* con, lir::TernaryOperation op, unsigned size,
-         lir::Register* a, lir::Memory* b,
-         lir::Constant* target)
+void branchRM(Context* con,
+              lir::TernaryOperation op,
+              unsigned size,
+              lir::Register* a,
+              lir::Memory* b,
+              lir::Constant* target)
 {
   assertT(con, !isFloatBranch(op));
   assertT(con, size <= vm::TargetBytesPerWord);
@@ -1124,9 +1410,12 @@ void branchRM(Context* con, lir::TernaryOperation op, unsigned size,
   branch(con, op, target);
 }
 
-void branchCM(Context* con, lir::TernaryOperation op, unsigned size,
-         lir::Constant* a, lir::Memory* b,
-         lir::Constant* target)
+void branchCM(Context* con,
+              lir::TernaryOperation op,
+              unsigned size,
+              lir::Constant* a,
+              lir::Memory* b,
+              lir::Constant* target)
 {
   assertT(con, !isFloatBranch(op));
   assertT(con, size <= vm::TargetBytesPerWord);
@@ -1135,25 +1424,27 @@ void branchCM(Context* con, lir::TernaryOperation op, unsigned size,
   branch(con, op, target);
 }
 
-ShiftMaskPromise*
-shiftMaskPromise(Context* con, Promise* base, unsigned shift, int64_t mask)
+ShiftMaskPromise* shiftMaskPromise(Context* con,
+                                   Promise* base,
+                                   unsigned shift,
+                                   int64_t mask)
 {
-  return new(con->zone) ShiftMaskPromise(base, shift, mask);
+  return new (con->zone) ShiftMaskPromise(base, shift, mask);
 }
 
-void moveCM(Context* con, unsigned srcSize, lir::Constant* src,
-       unsigned dstSize, lir::Memory* dst)
+void moveCM(Context* con,
+            unsigned srcSize,
+            lir::Constant* src,
+            unsigned dstSize,
+            lir::Memory* dst)
 {
   switch (dstSize) {
   case 8: {
-    lir::Constant srcHigh
-      (shiftMaskPromise(con, src->value, 32, 0xFFFFFFFF));
-    lir::Constant srcLow
-      (shiftMaskPromise(con, src->value, 0, 0xFFFFFFFF));
-    
-    lir::Memory dstLow
-      (dst->base, dst->offset + 4, dst->index, dst->scale);
-    
+    lir::Constant srcHigh(shiftMaskPromise(con, src->value, 32, 0xFFFFFFFF));
+    lir::Constant srcLow(shiftMaskPromise(con, src->value, 0, 0xFFFFFFFF));
+
+    lir::Memory dstLow(dst->base, dst->offset + 4, dst->index, dst->scale);
+
     moveCM(con, 4, &srcLow, 4, &dstLow);
     moveCM(con, 4, &srcHigh, 4, dst);
   } break;
@@ -1166,8 +1457,11 @@ void moveCM(Context* con, unsigned srcSize, lir::Constant* src,
   }
 }
 
-void negateRR(Context* con, unsigned srcSize, lir::Register* src,
-         unsigned dstSize UNUSED, lir::Register* dst)
+void negateRR(Context* con,
+              unsigned srcSize,
+              lir::Register* src,
+              unsigned dstSize UNUSED,
+              lir::Register* dst)
 {
   assertT(con, srcSize == dstSize);
 
@@ -1206,7 +1500,7 @@ void longJumpC(Context* con, unsigned size UNUSED, lir::Constant* target)
 {
   assertT(con, size == vm::TargetBytesPerWord);
 
-  lir::Register tmp(4); // a non-arg reg that we don't mind clobbering
+  lir::Register tmp(4);  // a non-arg reg that we don't mind clobbering
   moveCR2(con, vm::TargetBytesPerWord, target, &tmp, offsetPromise(con));
   jumpR(con, vm::TargetBytesPerWord, &tmp);
 }
@@ -1257,6 +1551,6 @@ void storeLoadBarrier(Context* con)
   memoryBarrier(con);
 }
 
-} // namespace arm
-} // namespace codegen
-} // namespace avian
+}  // namespace arm
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/target/arm/operations.h b/src/codegen/target/arm/operations.h
index 3a2d10f705..4c3f53cb56 100644
--- a/src/codegen/target/arm/operations.h
+++ b/src/codegen/target/arm/operations.h
@@ -25,51 +25,87 @@ class Context;
 
 // shortcut functions
 
-inline int newTemp(Context* con) {
+inline int newTemp(Context* con)
+{
   return con->client->acquireTemporary(GPR_MASK);
 }
 
-inline int newTemp(Context* con, unsigned mask) {
+inline int newTemp(Context* con, unsigned mask)
+{
   return con->client->acquireTemporary(mask);
 }
 
-inline void freeTemp(Context* con, int r) {
+inline void freeTemp(Context* con, int r)
+{
   con->client->releaseTemporary(r);
 }
 
-inline int64_t getValue(lir::Constant* con) {
+inline int64_t getValue(lir::Constant* con)
+{
   return con->value->value();
 }
 
-inline lir::Register makeTemp(Context* con) {
+inline lir::Register makeTemp(Context* con)
+{
   lir::Register tmp(newTemp(con));
   return tmp;
 }
 
-inline lir::Register makeTemp64(Context* con) {
+inline lir::Register makeTemp64(Context* con)
+{
   lir::Register tmp(newTemp(con), newTemp(con));
   return tmp;
 }
 
-inline void freeTemp(Context* con, const lir::Register& tmp) {
-  if (tmp.low != lir::NoRegister) freeTemp(con, tmp.low);
-  if (tmp.high != lir::NoRegister) freeTemp(con, tmp.high);
+inline void freeTemp(Context* con, const lir::Register& tmp)
+{
+  if (tmp.low != lir::NoRegister)
+    freeTemp(con, tmp.low);
+  if (tmp.high != lir::NoRegister)
+    freeTemp(con, tmp.high);
 }
 
-void shiftLeftR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t);
+void shiftLeftR(Context* con,
+                unsigned size,
+                lir::Register* a,
+                lir::Register* b,
+                lir::Register* t);
 
-void moveRR(Context* con, unsigned srcSize, lir::Register* src,
-       unsigned dstSize, lir::Register* dst);
+void moveRR(Context* con,
+            unsigned srcSize,
+            lir::Register* src,
+            unsigned dstSize,
+            lir::Register* dst);
 
-void shiftLeftC(Context* con, unsigned size UNUSED, lir::Constant* a, lir::Register* b, lir::Register* t);
+void shiftLeftC(Context* con,
+                unsigned size UNUSED,
+                lir::Constant* a,
+                lir::Register* b,
+                lir::Register* t);
 
-void shiftRightR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t);
+void shiftRightR(Context* con,
+                 unsigned size,
+                 lir::Register* a,
+                 lir::Register* b,
+                 lir::Register* t);
 
-void shiftRightC(Context* con, unsigned size UNUSED, lir::Constant* a, lir::Register* b, lir::Register* t);
+void shiftRightC(Context* con,
+                 unsigned size UNUSED,
+                 lir::Constant* a,
+                 lir::Register* b,
+                 lir::Register* t);
 
-void unsignedShiftRightR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t);
+void unsignedShiftRightR(Context* con,
+                         unsigned size,
+                         lir::Register* a,
+                         lir::Register* b,
+                         lir::Register* t);
 
-void unsignedShiftRightC(Context* con, unsigned size UNUSED, lir::Constant* a, lir::Register* b, lir::Register* t);
+void unsignedShiftRightC(Context* con,
+                         unsigned size UNUSED,
+                         lir::Constant* a,
+                         lir::Register* b,
+                         lir::Register* t);
 
 bool needJump(MyBlock* b);
 
@@ -79,142 +115,297 @@ void resolve(MyBlock* b);
 
 void jumpR(Context* con, unsigned size UNUSED, lir::Register* target);
 
-void swapRR(Context* con, unsigned aSize, lir::Register* a,
-       unsigned bSize, lir::Register* b);
+void swapRR(Context* con,
+            unsigned aSize,
+            lir::Register* a,
+            unsigned bSize,
+            lir::Register* b);
 
-void moveRR(Context* con, unsigned srcSize, lir::Register* src,
-       unsigned dstSize, lir::Register* dst);
+void moveRR(Context* con,
+            unsigned srcSize,
+            lir::Register* src,
+            unsigned dstSize,
+            lir::Register* dst);
 
-void moveZRR(Context* con, unsigned srcSize, lir::Register* src,
-        unsigned, lir::Register* dst);
+void moveZRR(Context* con,
+             unsigned srcSize,
+             lir::Register* src,
+             unsigned,
+             lir::Register* dst);
 
-void moveCR(Context* con, unsigned size, lir::Constant* src,
-            unsigned, lir::Register* dst);
+void moveCR(Context* con,
+            unsigned size,
+            lir::Constant* src,
+            unsigned,
+            lir::Register* dst);
 
-void moveCR2(Context* con, unsigned size, lir::Constant* src,
-        lir::Register* dst, Promise* callOffset);
+void moveCR2(Context* con,
+             unsigned size,
+             lir::Constant* src,
+             lir::Register* dst,
+             Promise* callOffset);
 
-void moveCR(Context* con, unsigned size, lir::Constant* src,
-       unsigned, lir::Register* dst);
+void moveCR(Context* con,
+            unsigned size,
+            lir::Constant* src,
+            unsigned,
+            lir::Register* dst);
 
-void addR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t);
+void addR(Context* con,
+          unsigned size,
+          lir::Register* a,
+          lir::Register* b,
+          lir::Register* t);
 
-void subR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t);
+void subR(Context* con,
+          unsigned size,
+          lir::Register* a,
+          lir::Register* b,
+          lir::Register* t);
 
-void addC(Context* con, unsigned size, lir::Constant* a,
-     lir::Register* b, lir::Register* dst);
+void addC(Context* con,
+          unsigned size,
+          lir::Constant* a,
+          lir::Register* b,
+          lir::Register* dst);
 
-void subC(Context* con, unsigned size, lir::Constant* a,
-     lir::Register* b, lir::Register* dst);
+void subC(Context* con,
+          unsigned size,
+          lir::Constant* a,
+          lir::Register* b,
+          lir::Register* dst);
 
-void multiplyR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t);
+void multiplyR(Context* con,
+               unsigned size,
+               lir::Register* a,
+               lir::Register* b,
+               lir::Register* t);
 
-void floatAbsoluteRR(Context* con, unsigned size, lir::Register* a, unsigned, lir::Register* b);
+void floatAbsoluteRR(Context* con,
+                     unsigned size,
+                     lir::Register* a,
+                     unsigned,
+                     lir::Register* b);
 
-void floatNegateRR(Context* con, unsigned size, lir::Register* a, unsigned, lir::Register* b);
+void floatNegateRR(Context* con,
+                   unsigned size,
+                   lir::Register* a,
+                   unsigned,
+                   lir::Register* b);
 
-void float2FloatRR(Context* con, unsigned size, lir::Register* a, unsigned, lir::Register* b);
+void float2FloatRR(Context* con,
+                   unsigned size,
+                   lir::Register* a,
+                   unsigned,
+                   lir::Register* b);
 
-void float2IntRR(Context* con, unsigned size, lir::Register* a, unsigned, lir::Register* b);
+void float2IntRR(Context* con,
+                 unsigned size,
+                 lir::Register* a,
+                 unsigned,
+                 lir::Register* b);
 
-void int2FloatRR(Context* con, unsigned, lir::Register* a, unsigned size, lir::Register* b);
+void int2FloatRR(Context* con,
+                 unsigned,
+                 lir::Register* a,
+                 unsigned size,
+                 lir::Register* b);
 
-void floatSqrtRR(Context* con, unsigned size, lir::Register* a, unsigned, lir::Register* b);
+void floatSqrtRR(Context* con,
+                 unsigned size,
+                 lir::Register* a,
+                 unsigned,
+                 lir::Register* b);
 
-void floatAddR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t);
+void floatAddR(Context* con,
+               unsigned size,
+               lir::Register* a,
+               lir::Register* b,
+               lir::Register* t);
 
-void floatSubtractR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t);
+void floatSubtractR(Context* con,
+                    unsigned size,
+                    lir::Register* a,
+                    lir::Register* b,
+                    lir::Register* t);
 
-void floatMultiplyR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t);
+void floatMultiplyR(Context* con,
+                    unsigned size,
+                    lir::Register* a,
+                    lir::Register* b,
+                    lir::Register* t);
 
-void floatDivideR(Context* con, unsigned size, lir::Register* a, lir::Register* b, lir::Register* t);
+void floatDivideR(Context* con,
+                  unsigned size,
+                  lir::Register* a,
+                  lir::Register* b,
+                  lir::Register* t);
 
-int normalize(Context* con, int offset, int index, unsigned scale, 
-          bool* preserveIndex, bool* release);
+int normalize(Context* con,
+              int offset,
+              int index,
+              unsigned scale,
+              bool* preserveIndex,
+              bool* release);
 
-void store(Context* con, unsigned size, lir::Register* src,
-      int base, int offset, int index, unsigned scale, bool preserveIndex);
+void store(Context* con,
+           unsigned size,
+           lir::Register* src,
+           int base,
+           int offset,
+           int index,
+           unsigned scale,
+           bool preserveIndex);
 
-void moveRM(Context* con, unsigned srcSize, lir::Register* src,
-       unsigned dstSize UNUSED, lir::Memory* dst);
+void moveRM(Context* con,
+            unsigned srcSize,
+            lir::Register* src,
+            unsigned dstSize UNUSED,
+            lir::Memory* dst);
 
-void load(Context* con, unsigned srcSize, int base, int offset, int index,
-     unsigned scale, unsigned dstSize, lir::Register* dst,
-     bool preserveIndex, bool signExtend);
+void load(Context* con,
+          unsigned srcSize,
+          int base,
+          int offset,
+          int index,
+          unsigned scale,
+          unsigned dstSize,
+          lir::Register* dst,
+          bool preserveIndex,
+          bool signExtend);
 
-void moveMR(Context* con, unsigned srcSize, lir::Memory* src,
-       unsigned dstSize, lir::Register* dst);
+void moveMR(Context* con,
+            unsigned srcSize,
+            lir::Memory* src,
+            unsigned dstSize,
+            lir::Register* dst);
 
-void moveZMR(Context* con, unsigned srcSize, lir::Memory* src,
-        unsigned dstSize, lir::Register* dst);
+void moveZMR(Context* con,
+             unsigned srcSize,
+             lir::Memory* src,
+             unsigned dstSize,
+             lir::Register* dst);
 
-void andR(Context* con, unsigned size, lir::Register* a,
-     lir::Register* b, lir::Register* dst);
+void andR(Context* con,
+          unsigned size,
+          lir::Register* a,
+          lir::Register* b,
+          lir::Register* dst);
 
-void andC(Context* con, unsigned size, lir::Constant* a,
-     lir::Register* b, lir::Register* dst);
+void andC(Context* con,
+          unsigned size,
+          lir::Constant* a,
+          lir::Register* b,
+          lir::Register* dst);
 
-void orR(Context* con, unsigned size, lir::Register* a,
-    lir::Register* b, lir::Register* dst);
+void orR(Context* con,
+         unsigned size,
+         lir::Register* a,
+         lir::Register* b,
+         lir::Register* dst);
 
-void xorR(Context* con, unsigned size, lir::Register* a,
-     lir::Register* b, lir::Register* dst);
+void xorR(Context* con,
+          unsigned size,
+          lir::Register* a,
+          lir::Register* b,
+          lir::Register* dst);
 
-void moveAR2(Context* con, unsigned srcSize, lir::Address* src,
-       unsigned dstSize, lir::Register* dst);
+void moveAR2(Context* con,
+             unsigned srcSize,
+             lir::Address* src,
+             unsigned dstSize,
+             lir::Register* dst);
 
-void moveAR(Context* con, unsigned srcSize, lir::Address* src,
-       unsigned dstSize, lir::Register* dst);
+void moveAR(Context* con,
+            unsigned srcSize,
+            lir::Address* src,
+            unsigned dstSize,
+            lir::Register* dst);
 
-void compareRR(Context* con, unsigned aSize, lir::Register* a,
-          unsigned bSize UNUSED, lir::Register* b);
+void compareRR(Context* con,
+               unsigned aSize,
+               lir::Register* a,
+               unsigned bSize UNUSED,
+               lir::Register* b);
 
-void compareCR(Context* con, unsigned aSize, lir::Constant* a,
-          unsigned bSize, lir::Register* b);
+void compareCR(Context* con,
+               unsigned aSize,
+               lir::Constant* a,
+               unsigned bSize,
+               lir::Register* b);
 
-void compareCM(Context* con, unsigned aSize, lir::Constant* a,
-          unsigned bSize, lir::Memory* b);
+void compareCM(Context* con,
+               unsigned aSize,
+               lir::Constant* a,
+               unsigned bSize,
+               lir::Memory* b);
 
-void compareRM(Context* con, unsigned aSize, lir::Register* a,
-          unsigned bSize, lir::Memory* b);
+void compareRM(Context* con,
+               unsigned aSize,
+               lir::Register* a,
+               unsigned bSize,
+               lir::Memory* b);
 
-int32_t
-branch(Context* con, lir::TernaryOperation op);
+int32_t branch(Context* con, lir::TernaryOperation op);
 
 void conditional(Context* con, int32_t branch, lir::Constant* target);
 
 void branch(Context* con, lir::TernaryOperation op, lir::Constant* target);
 
-void branchLong(Context* con, lir::TernaryOperation op, lir::Operand* al,
-           lir::Operand* ah, lir::Operand* bl,
-           lir::Operand* bh, lir::Constant* target,
-           BinaryOperationType compareSigned,
-           BinaryOperationType compareUnsigned);
+void branchLong(Context* con,
+                lir::TernaryOperation op,
+                lir::Operand* al,
+                lir::Operand* ah,
+                lir::Operand* bl,
+                lir::Operand* bh,
+                lir::Constant* target,
+                BinaryOperationType compareSigned,
+                BinaryOperationType compareUnsigned);
 
-void branchRR(Context* con, lir::TernaryOperation op, unsigned size,
-         lir::Register* a, lir::Register* b,
-         lir::Constant* target);
+void branchRR(Context* con,
+              lir::TernaryOperation op,
+              unsigned size,
+              lir::Register* a,
+              lir::Register* b,
+              lir::Constant* target);
 
-void branchCR(Context* con, lir::TernaryOperation op, unsigned size,
-         lir::Constant* a, lir::Register* b,
-         lir::Constant* target);
+void branchCR(Context* con,
+              lir::TernaryOperation op,
+              unsigned size,
+              lir::Constant* a,
+              lir::Register* b,
+              lir::Constant* target);
 
-void branchRM(Context* con, lir::TernaryOperation op, unsigned size,
-         lir::Register* a, lir::Memory* b,
-         lir::Constant* target);
+void branchRM(Context* con,
+              lir::TernaryOperation op,
+              unsigned size,
+              lir::Register* a,
+              lir::Memory* b,
+              lir::Constant* target);
 
-void branchCM(Context* con, lir::TernaryOperation op, unsigned size,
-         lir::Constant* a, lir::Memory* b,
-         lir::Constant* target);
+void branchCM(Context* con,
+              lir::TernaryOperation op,
+              unsigned size,
+              lir::Constant* a,
+              lir::Memory* b,
+              lir::Constant* target);
 
-ShiftMaskPromise*
-shiftMaskPromise(Context* con, Promise* base, unsigned shift, int64_t mask);
+ShiftMaskPromise* shiftMaskPromise(Context* con,
+                                   Promise* base,
+                                   unsigned shift,
+                                   int64_t mask);
 
-void moveCM(Context* con, unsigned srcSize, lir::Constant* src,
-       unsigned dstSize, lir::Memory* dst);
+void moveCM(Context* con,
+            unsigned srcSize,
+            lir::Constant* src,
+            unsigned dstSize,
+            lir::Memory* dst);
 
-void negateRR(Context* con, unsigned srcSize, lir::Register* src,
-         unsigned dstSize UNUSED, lir::Register* dst);
+void negateRR(Context* con,
+              unsigned srcSize,
+              lir::Register* src,
+              unsigned dstSize UNUSED,
+              lir::Register* dst);
 
 void callR(Context* con, unsigned size UNUSED, lir::Register* target);
 
@@ -236,9 +427,8 @@ void storeStoreBarrier(Context*);
 
 void storeLoadBarrier(Context*);
 
-} // namespace arm
-} // namespace codegen
-} // namespace avian
-
-#endif // AVIAN_CODEGEN_ASSEMBLER_ARM_OPERATIONS_H
+}  // namespace arm
+}  // namespace codegen
+}  // namespace avian
 
+#endif  // AVIAN_CODEGEN_ASSEMBLER_ARM_OPERATIONS_H
diff --git a/src/codegen/target/arm/registers.h b/src/codegen/target/arm/registers.h
index fdb6cf0891..f6d0a9d7fa 100644
--- a/src/codegen/target/arm/registers.h
+++ b/src/codegen/target/arm/registers.h
@@ -18,10 +18,9 @@ namespace avian {
 namespace codegen {
 namespace arm {
 
-
 const uint64_t MASK_LO32 = 0xffffffff;
 const unsigned MASK_LO16 = 0xffff;
-const unsigned MASK_LO8  = 0xff;
+const unsigned MASK_LO8 = 0xff;
 
 const int N_GPRS = 16;
 const int N_FPRS = 16;
@@ -31,22 +30,35 @@ const uint32_t FPR_MASK = 0xffff0000;
 const uint64_t GPR_MASK64 = GPR_MASK | (uint64_t)GPR_MASK << 32;
 const uint64_t FPR_MASK64 = FPR_MASK | (uint64_t)FPR_MASK << 32;
 
-inline bool isFpr(lir::Register* reg) {
+inline bool isFpr(lir::Register* reg)
+{
   return reg->low >= N_GPRS;
 }
 
-inline int fpr64(int reg) { return reg - N_GPRS; }
-inline int fpr64(lir::Register* reg) { return fpr64(reg->low); }
-inline int fpr32(int reg) { return fpr64(reg) << 1; }
-inline int fpr32(lir::Register* reg) { return fpr64(reg) << 1; }
+inline int fpr64(int reg)
+{
+  return reg - N_GPRS;
+}
+inline int fpr64(lir::Register* reg)
+{
+  return fpr64(reg->low);
+}
+inline int fpr32(int reg)
+{
+  return fpr64(reg) << 1;
+}
+inline int fpr32(lir::Register* reg)
+{
+  return fpr64(reg) << 1;
+}
 
 const int ThreadRegister = 8;
 const int StackRegister = 13;
 const int LinkRegister = 14;
 const int ProgramCounter = 15;
 
-} // namespace arm
-} // namespace codegen
-} // namespace avian
+}  // namespace arm
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_ASSEMBLER_ARM_REGISTERS_H
+#endif  // AVIAN_CODEGEN_ASSEMBLER_ARM_REGISTERS_H
diff --git a/src/codegen/target/multimethod.h b/src/codegen/target/multimethod.h
index 1a0890d851..e5de2ca23c 100644
--- a/src/codegen/target/multimethod.h
+++ b/src/codegen/target/multimethod.h
@@ -11,19 +11,19 @@
 #ifndef AVIAN_CODEGEN_TARGET_MULTIMETHOD_H
 #define AVIAN_CODEGEN_TARGET_MULTIMETHOD_H
 
-
 namespace avian {
 namespace codegen {
 
 class Multimethod {
-public:
-  inline static unsigned index(lir::UnaryOperation operation, lir::OperandType operand) {
+ public:
+  inline static unsigned index(lir::UnaryOperation operation,
+                               lir::OperandType operand)
+  {
     return operation + (lir::UnaryOperationCount * operand);
   }
 };
 
-} // namespace codegen
-} // namespace avian
-
-#endif // AVIAN_CODEGEN_TARGET_MULTIMETHOD_H
+}  // namespace codegen
+}  // namespace avian
 
+#endif  // AVIAN_CODEGEN_TARGET_MULTIMETHOD_H
diff --git a/src/codegen/target/x86/assembler.cpp b/src/codegen/target/x86/assembler.cpp
index cf20da347f..e124a97a85 100644
--- a/src/codegen/target/x86/assembler.cpp
+++ b/src/codegen/target/x86/assembler.cpp
@@ -54,25 +54,30 @@ namespace x86 {
 const unsigned FrameHeaderSize = (UseFramePointer ? 2 : 1);
 
 const unsigned StackAlignmentInBytes = 16;
-const unsigned StackAlignmentInWords = StackAlignmentInBytes / TargetBytesPerWord;
+const unsigned StackAlignmentInWords = StackAlignmentInBytes
+                                       / TargetBytesPerWord;
 
-unsigned
-argumentFootprint(unsigned footprint)
+unsigned argumentFootprint(unsigned footprint)
 {
   return max(pad(footprint, StackAlignmentInWords), StackAlignmentInWords);
 }
 
-uint32_t
-read4(uint8_t* p)
+uint32_t read4(uint8_t* p)
 {
-  uint32_t v; memcpy(&v, p, 4);
+  uint32_t v;
+  memcpy(&v, p, 4);
   return v;
 }
 
-void
-nextFrame(ArchitectureContext* c UNUSED, uint8_t* start, unsigned size UNUSED,
-          unsigned footprint, void*, bool mostRecent,
-          int targetParameterFootprint, void** ip, void** stack)
+void nextFrame(ArchitectureContext* c UNUSED,
+               uint8_t* start,
+               unsigned size UNUSED,
+               unsigned footprint,
+               void*,
+               bool mostRecent,
+               int targetParameterFootprint,
+               void** ip,
+               void** stack)
 {
   assertT(c, *ip >= start);
   assertT(c, *ip <= start + size);
@@ -107,7 +112,7 @@ nextFrame(ArchitectureContext* c UNUSED, uint8_t* start, unsigned size UNUSED,
     }
   }
 
-  if (*instruction == 0xc3) { // return
+  if (*instruction == 0xc3) {  // return
     *ip = static_cast<void**>(*stack)[0];
     return;
   }
@@ -117,31 +122,29 @@ nextFrame(ArchitectureContext* c UNUSED, uint8_t* start, unsigned size UNUSED,
   if (TailCalls and targetParameterFootprint >= 0) {
     if (argumentFootprint(targetParameterFootprint) > StackAlignmentInWords) {
       offset += argumentFootprint(targetParameterFootprint)
-        - StackAlignmentInWords;
+                - StackAlignmentInWords;
     }
 
     // check for post-non-tail-call stack adjustment of the form "sub
     // $offset,%rsp":
     if (TargetBytesPerWord == 4) {
       if ((*instruction == 0x83 or *instruction == 0x81)
-          and instruction[1] == 0xec)
-      {
+          and instruction[1] == 0xec) {
         offset
-          -= (*instruction == 0x83 ? instruction[2] : read4(instruction + 2))
-          / TargetBytesPerWord;
+            -= (*instruction == 0x83 ? instruction[2] : read4(instruction + 2))
+               / TargetBytesPerWord;
       }
     } else if (*instruction == 0x48
                and (instruction[1] == 0x83 or instruction[1] == 0x81)
-               and instruction[2] == 0xec)
-    {
+               and instruction[2] == 0xec) {
       offset
-        -= (instruction[1] == 0x83 ? instruction[3] : read4(instruction + 3))
-        / TargetBytesPerWord;
+          -= (instruction[1] == 0x83 ? instruction[3] : read4(instruction + 3))
+             / TargetBytesPerWord;
     }
 
     // todo: check for and handle tail calls
   }
-  
+
   if (UseFramePointer and not mostRecent) {
     assertT(c,
             static_cast<void***>(*stack)[-1] + 1
@@ -156,17 +159,18 @@ nextFrame(ArchitectureContext* c UNUSED, uint8_t* start, unsigned size UNUSED,
   *stack = static_cast<void**>(*stack) + offset;
 }
 
-class MyArchitecture: public Architecture {
+class MyArchitecture : public Architecture {
  public:
-  MyArchitecture(System* system, bool useNativeFeatures):
-    c(system, useNativeFeatures),
-    referenceCount(0),
-    myRegisterFile(GeneralRegisterMask, useSSE(&c) ? FloatRegisterMask : 0)
+  MyArchitecture(System* system, bool useNativeFeatures)
+      : c(system, useNativeFeatures),
+        referenceCount(0),
+        myRegisterFile(GeneralRegisterMask, useSSE(&c) ? FloatRegisterMask : 0)
   {
     populateTables(&c);
   }
 
-  virtual unsigned floatRegisterSize() {
+  virtual unsigned floatRegisterSize()
+  {
     if (useSSE(&c)) {
       return 8;
     } else {
@@ -174,35 +178,43 @@ class MyArchitecture: public Architecture {
     }
   }
 
-  virtual const RegisterFile* registerFile() {
+  virtual const RegisterFile* registerFile()
+  {
     return &myRegisterFile;
   }
 
-  virtual int scratch() {
+  virtual int scratch()
+  {
     return rax;
   }
 
-  virtual int stack() {
+  virtual int stack()
+  {
     return rsp;
   }
 
-  virtual int thread() {
+  virtual int thread()
+  {
     return rbx;
   }
 
-  virtual int returnLow() {
+  virtual int returnLow()
+  {
     return rax;
   }
 
-  virtual int returnHigh() {
+  virtual int returnHigh()
+  {
     return (TargetBytesPerWord == 4 ? rdx : lir::NoRegister);
   }
 
-  virtual int virtualCallTarget() {
+  virtual int virtualCallTarget()
+  {
     return rax;
   }
 
-  virtual int virtualCallIndex() {
+  virtual int virtualCallIndex()
+  {
     return rdx;
   }
 
@@ -211,15 +223,18 @@ class MyArchitecture: public Architecture {
     return ir::TargetInfo(TargetBytesPerWord);
   }
 
-  virtual bool bigEndian() {
+  virtual bool bigEndian()
+  {
     return false;
   }
 
-  virtual uintptr_t maximumImmediateJump() {
+  virtual uintptr_t maximumImmediateJump()
+  {
     return 0x7FFFFFFF;
   }
 
-  virtual bool reserved(int register_) {
+  virtual bool reserved(int register_)
+  {
     switch (register_) {
     case rbp:
       return UseFramePointer;
@@ -227,44 +242,55 @@ class MyArchitecture: public Architecture {
     case rsp:
     case rbx:
       return true;
-   	  
+
     default:
       return false;
     }
   }
 
-  virtual unsigned frameFootprint(unsigned footprint) {
+  virtual unsigned frameFootprint(unsigned footprint)
+  {
 #if AVIAN_TARGET_FORMAT == AVIAN_FORMAT_PE
     return max(footprint, StackAlignmentInWords);
 #else
-    return max(footprint > argumentRegisterCount() ?
-               footprint - argumentRegisterCount() : 0,
+    return max(footprint > argumentRegisterCount()
+                   ? footprint - argumentRegisterCount()
+                   : 0,
                StackAlignmentInWords);
 #endif
   }
 
-  virtual unsigned argumentFootprint(unsigned footprint) {
+  virtual unsigned argumentFootprint(unsigned footprint)
+  {
     return x86::argumentFootprint(footprint);
   }
 
-  virtual bool argumentAlignment() {
+  virtual bool argumentAlignment()
+  {
     return false;
   }
 
-  virtual bool argumentRegisterAlignment() {
+  virtual bool argumentRegisterAlignment()
+  {
     return false;
   }
 
-  virtual unsigned argumentRegisterCount() {
+  virtual unsigned argumentRegisterCount()
+  {
 #if AVIAN_TARGET_FORMAT == AVIAN_FORMAT_PE
-    if (TargetBytesPerWord == 8) return 4; else
+    if (TargetBytesPerWord == 8)
+      return 4;
+    else
 #else
-    if (TargetBytesPerWord == 8) return 6; else
+    if (TargetBytesPerWord == 8)
+      return 6;
+    else
 #endif
-    return 0;
+      return 0;
   }
 
-  virtual int argumentRegister(unsigned index) {
+  virtual int argumentRegister(unsigned index)
+  {
     assertT(&c, TargetBytesPerWord == 8);
     switch (index) {
 #if AVIAN_TARGET_FORMAT == AVIAN_FORMAT_PE
@@ -295,23 +321,28 @@ class MyArchitecture: public Architecture {
     }
   }
 
-  virtual bool hasLinkRegister() {
+  virtual bool hasLinkRegister()
+  {
     return false;
   }
 
-  virtual unsigned stackAlignmentInWords() {
+  virtual unsigned stackAlignmentInWords()
+  {
     return StackAlignmentInWords;
   }
 
-  virtual bool matchCall(void* returnAddress, void* target) {
+  virtual bool matchCall(void* returnAddress, void* target)
+  {
     uint8_t* instruction = static_cast<uint8_t*>(returnAddress) - 5;
-    int32_t actualOffset; memcpy(&actualOffset, instruction + 1, 4);
+    int32_t actualOffset;
+    memcpy(&actualOffset, instruction + 1, 4);
     void* actualTarget = static_cast<uint8_t*>(returnAddress) + actualOffset;
 
     return *instruction == 0xE8 and actualTarget == target;
   }
 
-  virtual void updateCall(lir::UnaryOperation op, void* returnAddress,
+  virtual void updateCall(lir::UnaryOperation op,
+                          void* returnAddress,
                           void* newTarget)
   {
     bool assertTAlignment UNUSED;
@@ -354,7 +385,7 @@ class MyArchitecture: public Architecture {
               or reinterpret_cast<uintptr_t>(instruction + 1) % 4 == 0);
 
       intptr_t v = static_cast<uint8_t*>(newTarget)
-        - static_cast<uint8_t*>(returnAddress);
+                   - static_cast<uint8_t*>(returnAddress);
 
       assertT(&c, vm::fitsInInt32(v));
 
@@ -378,43 +409,61 @@ class MyArchitecture: public Architecture {
     }
   }
 
-  virtual void setConstant(void* dst, uint64_t constant) {
+  virtual void setConstant(void* dst, uint64_t constant)
+  {
     target_uintptr_t v = targetVW(constant);
     memcpy(dst, &v, TargetBytesPerWord);
   }
 
-  virtual unsigned alignFrameSize(unsigned sizeInWords) {
+  virtual unsigned alignFrameSize(unsigned sizeInWords)
+  {
     return pad(sizeInWords + FrameHeaderSize, StackAlignmentInWords)
-      - FrameHeaderSize;
+           - FrameHeaderSize;
   }
 
-  virtual void nextFrame(void* start, unsigned size, unsigned footprint,
-                         void* link, bool mostRecent,
-                         int targetParameterFootprint, void** ip,
+  virtual void nextFrame(void* start,
+                         unsigned size,
+                         unsigned footprint,
+                         void* link,
+                         bool mostRecent,
+                         int targetParameterFootprint,
+                         void** ip,
                          void** stack)
   {
-    x86::nextFrame(&c, static_cast<uint8_t*>(start), size, footprint,
-                     link, mostRecent, targetParameterFootprint, ip, stack);
+    x86::nextFrame(&c,
+                   static_cast<uint8_t*>(start),
+                   size,
+                   footprint,
+                   link,
+                   mostRecent,
+                   targetParameterFootprint,
+                   ip,
+                   stack);
   }
 
-  virtual void* frameIp(void* stack) {
+  virtual void* frameIp(void* stack)
+  {
     return stack ? *static_cast<void**>(stack) : 0;
   }
 
-  virtual unsigned frameHeaderSize() {
+  virtual unsigned frameHeaderSize()
+  {
     return FrameHeaderSize;
   }
 
-  virtual unsigned frameReturnAddressSize() {
+  virtual unsigned frameReturnAddressSize()
+  {
     return 1;
   }
 
-  virtual unsigned frameFooterSize() {
+  virtual unsigned frameFooterSize()
+  {
     return 0;
   }
 
-  virtual bool alwaysCondensed(lir::BinaryOperation op) {
-    switch(op) {
+  virtual bool alwaysCondensed(lir::BinaryOperation op)
+  {
+    switch (op) {
     case lir::Float2Float:
     case lir::Float2Int:
     case lir::Int2Float:
@@ -431,35 +480,40 @@ class MyArchitecture: public Architecture {
       abort(&c);
     }
   }
-  
-  virtual bool alwaysCondensed(lir::TernaryOperation) {
+
+  virtual bool alwaysCondensed(lir::TernaryOperation)
+  {
     return true;
   }
 
-  virtual int returnAddressOffset() {
+  virtual int returnAddressOffset()
+  {
     return 0;
   }
 
-  virtual int framePointerOffset() {
+  virtual int framePointerOffset()
+  {
     return UseFramePointer ? -1 : 0;
   }
 
-  virtual void plan
-  (lir::UnaryOperation,
-   unsigned, OperandMask& aMask,
-   bool* thunk)
+  virtual void plan(lir::UnaryOperation,
+                    unsigned,
+                    OperandMask& aMask,
+                    bool* thunk)
   {
-    aMask.typeMask = (1 << lir::RegisterOperand) | (1 << lir::MemoryOperand) | (1 << lir::ConstantOperand);
+    aMask.typeMask = (1 << lir::RegisterOperand) | (1 << lir::MemoryOperand)
+                     | (1 << lir::ConstantOperand);
     *thunk = false;
   }
 
-  virtual void planSource
-  (lir::BinaryOperation op,
-   unsigned aSize, OperandMask& aMask,
-   unsigned bSize, bool* thunk)
+  virtual void planSource(lir::BinaryOperation op,
+                          unsigned aSize,
+                          OperandMask& aMask,
+                          unsigned bSize,
+                          bool* thunk)
   {
-    aMask.registerMask = GeneralRegisterMask |
-      (static_cast<uint64_t>(GeneralRegisterMask) << 32);
+    aMask.registerMask = GeneralRegisterMask
+                         | (static_cast<uint64_t>(GeneralRegisterMask) << 32);
 
     *thunk = false;
 
@@ -467,7 +521,7 @@ class MyArchitecture: public Architecture {
     case lir::Negate:
       aMask.typeMask = (1 << lir::RegisterOperand);
       aMask.registerMask = (static_cast<uint64_t>(1) << (rdx + 32))
-        | (static_cast<uint64_t>(1) << rax);
+                           | (static_cast<uint64_t>(1) << rax);
       break;
 
     case lir::Absolute:
@@ -483,12 +537,12 @@ class MyArchitecture: public Architecture {
       if (useSSE(&c)) {
         aMask.typeMask = (1 << lir::RegisterOperand);
         aMask.registerMask = (static_cast<uint64_t>(FloatRegisterMask) << 32)
-          | FloatRegisterMask;
+                             | FloatRegisterMask;
       } else {
         *thunk = true;
       }
-      break;  
-  
+      break;
+
     case lir::FloatNegate:
       // floatNegateRR does not support doubles
       if (useSSE(&c) and aSize == 4 and bSize == 4) {
@@ -501,9 +555,10 @@ class MyArchitecture: public Architecture {
 
     case lir::FloatSquareRoot:
       if (useSSE(&c)) {
-        aMask.typeMask = (1 << lir::RegisterOperand) | (1 << lir::MemoryOperand);
+        aMask.typeMask = (1 << lir::RegisterOperand)
+                         | (1 << lir::MemoryOperand);
         aMask.registerMask = (static_cast<uint64_t>(FloatRegisterMask) << 32)
-          | FloatRegisterMask;
+                             | FloatRegisterMask;
       } else {
         *thunk = true;
       }
@@ -511,9 +566,10 @@ class MyArchitecture: public Architecture {
 
     case lir::Float2Float:
       if (useSSE(&c)) {
-        aMask.typeMask = (1 << lir::RegisterOperand) | (1 << lir::MemoryOperand);
+        aMask.typeMask = (1 << lir::RegisterOperand)
+                         | (1 << lir::MemoryOperand);
         aMask.registerMask = (static_cast<uint64_t>(FloatRegisterMask) << 32)
-          | FloatRegisterMask;
+                             | FloatRegisterMask;
       } else {
         *thunk = true;
       }
@@ -525,9 +581,10 @@ class MyArchitecture: public Architecture {
       // thunks or produce inline machine code which handles edge
       // cases properly.
       if (false and useSSE(&c) and bSize <= TargetBytesPerWord) {
-        aMask.typeMask = (1 << lir::RegisterOperand) | (1 << lir::MemoryOperand);
+        aMask.typeMask = (1 << lir::RegisterOperand)
+                         | (1 << lir::MemoryOperand);
         aMask.registerMask = (static_cast<uint64_t>(FloatRegisterMask) << 32)
-          | FloatRegisterMask;
+                             | FloatRegisterMask;
       } else {
         *thunk = true;
       }
@@ -535,9 +592,11 @@ class MyArchitecture: public Architecture {
 
     case lir::Int2Float:
       if (useSSE(&c) and aSize <= TargetBytesPerWord) {
-        aMask.typeMask = (1 << lir::RegisterOperand) | (1 << lir::MemoryOperand);
-        aMask.registerMask = GeneralRegisterMask
-          | (static_cast<uint64_t>(GeneralRegisterMask) << 32);
+        aMask.typeMask = (1 << lir::RegisterOperand)
+                         | (1 << lir::MemoryOperand);
+        aMask.registerMask
+            = GeneralRegisterMask
+              | (static_cast<uint64_t>(GeneralRegisterMask) << 32);
       } else {
         *thunk = true;
       }
@@ -549,15 +608,17 @@ class MyArchitecture: public Architecture {
 
       if (TargetBytesPerWord == 4) {
         if (aSize == 4 and bSize == 8) {
-          aMask.typeMask = (1 << lir::RegisterOperand) | (1 << lir::MemoryOperand);
-          const uint32_t mask
-            = GeneralRegisterMask & ~((1 << rax) | (1 << rdx));
-          aMask.registerMask = (static_cast<uint64_t>(mask) << 32) | mask;    
+          aMask.typeMask = (1 << lir::RegisterOperand)
+                           | (1 << lir::MemoryOperand);
+          const uint32_t mask = GeneralRegisterMask
+                                & ~((1 << rax) | (1 << rdx));
+          aMask.registerMask = (static_cast<uint64_t>(mask) << 32) | mask;
         } else if (aSize == 1 or bSize == 1) {
-          aMask.typeMask = (1 << lir::RegisterOperand) | (1 << lir::MemoryOperand);
-          const uint32_t mask
-            = (1 << rax) | (1 << rcx) | (1 << rdx) | (1 << rbx);
-          aMask.registerMask = (static_cast<uint64_t>(mask) << 32) | mask;     
+          aMask.typeMask = (1 << lir::RegisterOperand)
+                           | (1 << lir::MemoryOperand);
+          const uint32_t mask = (1 << rax) | (1 << rcx) | (1 << rdx)
+                                | (1 << rbx);
+          aMask.registerMask = (static_cast<uint64_t>(mask) << 32) | mask;
         }
       }
       break;
@@ -567,14 +628,15 @@ class MyArchitecture: public Architecture {
     }
   }
 
-  virtual void planDestination
-  (lir::BinaryOperation op,
-   unsigned aSize, const OperandMask& aMask,
-   unsigned bSize, OperandMask& bMask)
+  virtual void planDestination(lir::BinaryOperation op,
+                               unsigned aSize,
+                               const OperandMask& aMask,
+                               unsigned bSize,
+                               OperandMask& bMask)
   {
     bMask.typeMask = ~0;
     bMask.registerMask = GeneralRegisterMask
-      | (static_cast<uint64_t>(GeneralRegisterMask) << 32);
+                         | (static_cast<uint64_t>(GeneralRegisterMask) << 32);
 
     switch (op) {
     case lir::Absolute:
@@ -598,7 +660,7 @@ class MyArchitecture: public Architecture {
     case lir::Int2Float:
       bMask.typeMask = (1 << lir::RegisterOperand);
       bMask.registerMask = (static_cast<uint64_t>(FloatRegisterMask) << 32)
-        | FloatRegisterMask;
+                           | FloatRegisterMask;
       break;
 
     case lir::Float2Int:
@@ -606,30 +668,34 @@ class MyArchitecture: public Architecture {
       break;
 
     case lir::Move:
-      if (aMask.typeMask & ((1 << lir::MemoryOperand) | 1 << lir::AddressOperand)) {
+      if (aMask.typeMask
+          & ((1 << lir::MemoryOperand) | 1 << lir::AddressOperand)) {
         bMask.typeMask = (1 << lir::RegisterOperand);
         bMask.registerMask = GeneralRegisterMask
-          | (static_cast<uint64_t>(GeneralRegisterMask) << 32)
-          | FloatRegisterMask;
+                             | (static_cast<uint64_t>(GeneralRegisterMask)
+                                << 32) | FloatRegisterMask;
       } else if (aMask.typeMask & (1 << lir::RegisterOperand)) {
-        bMask.typeMask = (1 << lir::RegisterOperand) | (1 << lir::MemoryOperand);
+        bMask.typeMask = (1 << lir::RegisterOperand)
+                         | (1 << lir::MemoryOperand);
         if (aMask.registerMask & FloatRegisterMask) {
-          bMask.registerMask = FloatRegisterMask;          
+          bMask.registerMask = FloatRegisterMask;
         } else {
-          bMask.registerMask = GeneralRegisterMask
-            | (static_cast<uint64_t>(GeneralRegisterMask) << 32);
+          bMask.registerMask
+              = GeneralRegisterMask
+                | (static_cast<uint64_t>(GeneralRegisterMask) << 32);
         }
       } else {
-        bMask.typeMask = (1 << lir::RegisterOperand) | (1 << lir::MemoryOperand);
+        bMask.typeMask = (1 << lir::RegisterOperand)
+                         | (1 << lir::MemoryOperand);
       }
 
       if (TargetBytesPerWord == 4) {
         if (aSize == 4 and bSize == 8) {
           bMask.registerMask = (static_cast<uint64_t>(1) << (rdx + 32))
-            | (static_cast<uint64_t>(1) << rax);
+                               | (static_cast<uint64_t>(1) << rax);
         } else if (aSize == 1 or bSize == 1) {
-          const uint32_t mask
-            = (1 << rax) | (1 << rcx) | (1 << rdx) | (1 << rbx);
+          const uint32_t mask = (1 << rax) | (1 << rcx) | (1 << rdx)
+                                | (1 << rbx);
           bMask.registerMask = (static_cast<uint64_t>(mask) << 32) | mask;
         }
       }
@@ -640,10 +706,10 @@ class MyArchitecture: public Architecture {
     }
   }
 
-  virtual void planMove
-  (unsigned size, OperandMask& srcMask,
-   OperandMask& tmpMask,
-   const OperandMask& dstMask)
+  virtual void planMove(unsigned size,
+                        OperandMask& srcMask,
+                        OperandMask& tmpMask,
+                        const OperandMask& dstMask)
   {
     srcMask.typeMask = ~0;
     srcMask.registerMask = ~static_cast<uint64_t>(0);
@@ -653,21 +719,25 @@ class MyArchitecture: public Architecture {
 
     if (dstMask.typeMask & (1 << lir::MemoryOperand)) {
       // can't move directly from memory to memory
-      srcMask.typeMask = (1 << lir::RegisterOperand) | (1 << lir::ConstantOperand);
+      srcMask.typeMask = (1 << lir::RegisterOperand)
+                         | (1 << lir::ConstantOperand);
       tmpMask.typeMask = 1 << lir::RegisterOperand;
-      tmpMask.registerMask = GeneralRegisterMask
-        | (static_cast<uint64_t>(GeneralRegisterMask) << 32);
+      tmpMask.registerMask
+          = GeneralRegisterMask
+            | (static_cast<uint64_t>(GeneralRegisterMask) << 32);
     } else if (dstMask.typeMask & (1 << lir::RegisterOperand)) {
       if (size > TargetBytesPerWord) {
         // can't move directly from FPR to GPR or vice-versa for
         // values larger than the GPR size
         if (dstMask.registerMask & FloatRegisterMask) {
-          srcMask.registerMask = FloatRegisterMask
-            | (static_cast<uint64_t>(FloatRegisterMask) << 32);
-          tmpMask.typeMask = 1 << lir::MemoryOperand;          
+          srcMask.registerMask
+              = FloatRegisterMask
+                | (static_cast<uint64_t>(FloatRegisterMask) << 32);
+          tmpMask.typeMask = 1 << lir::MemoryOperand;
         } else if (dstMask.registerMask & GeneralRegisterMask) {
-          srcMask.registerMask = GeneralRegisterMask
-            | (static_cast<uint64_t>(GeneralRegisterMask) << 32);
+          srcMask.registerMask
+              = GeneralRegisterMask
+                | (static_cast<uint64_t>(GeneralRegisterMask) << 32);
           tmpMask.typeMask = 1 << lir::MemoryOperand;
         }
       }
@@ -677,27 +747,31 @@ class MyArchitecture: public Architecture {
         if (size > TargetBytesPerWord) {
           tmpMask.typeMask = 1 << lir::MemoryOperand;
         } else {
-          tmpMask.typeMask = (1 << lir::RegisterOperand) | (1 << lir::MemoryOperand);
-          tmpMask.registerMask = GeneralRegisterMask
-            | (static_cast<uint64_t>(GeneralRegisterMask) << 32);
+          tmpMask.typeMask = (1 << lir::RegisterOperand)
+                             | (1 << lir::MemoryOperand);
+          tmpMask.registerMask
+              = GeneralRegisterMask
+                | (static_cast<uint64_t>(GeneralRegisterMask) << 32);
         }
       }
     }
   }
 
-  virtual void planSource
-  (lir::TernaryOperation op,
-   unsigned aSize, OperandMask& aMask,
-   unsigned bSize, OperandMask& bMask,
-   unsigned, bool* thunk)
+  virtual void planSource(lir::TernaryOperation op,
+                          unsigned aSize,
+                          OperandMask& aMask,
+                          unsigned bSize,
+                          OperandMask& bMask,
+                          unsigned,
+                          bool* thunk)
   {
     aMask.typeMask = (1 << lir::RegisterOperand) | (1 << lir::ConstantOperand);
     aMask.registerMask = GeneralRegisterMask
-      | (static_cast<uint64_t>(GeneralRegisterMask) << 32);
+                         | (static_cast<uint64_t>(GeneralRegisterMask) << 32);
 
     bMask.typeMask = (1 << lir::RegisterOperand);
     bMask.registerMask = GeneralRegisterMask
-      | (static_cast<uint64_t>(GeneralRegisterMask) << 32);
+                         | (static_cast<uint64_t>(GeneralRegisterMask) << 32);
 
     *thunk = false;
 
@@ -707,12 +781,12 @@ class MyArchitecture: public Architecture {
     case lir::FloatMultiply:
     case lir::FloatDivide:
       if (useSSE(&c)) {
-        aMask.typeMask = (1 << lir::RegisterOperand) | (1 << lir::MemoryOperand);
+        aMask.typeMask = (1 << lir::RegisterOperand)
+                         | (1 << lir::MemoryOperand);
         bMask.typeMask = (1 << lir::RegisterOperand);
 
-        const uint64_t mask
-          = (static_cast<uint64_t>(FloatRegisterMask) << 32)
-          | FloatRegisterMask;
+        const uint64_t mask = (static_cast<uint64_t>(FloatRegisterMask) << 32)
+                              | FloatRegisterMask;
         aMask.registerMask = mask;
         bMask.registerMask = mask;
       } else {
@@ -723,9 +797,9 @@ class MyArchitecture: public Architecture {
     case lir::FloatRemainder:
       *thunk = true;
       break;
-   	  
+
     case lir::Multiply:
-      if (TargetBytesPerWord == 4 and aSize == 8) { 
+      if (TargetBytesPerWord == 4 and aSize == 8) {
         const uint32_t mask = GeneralRegisterMask & ~((1 << rax) | (1 << rdx));
         aMask.registerMask = (static_cast<uint64_t>(mask) << 32) | mask;
         bMask.registerMask = (static_cast<uint64_t>(1) << (rdx + 32)) | mask;
@@ -737,11 +811,11 @@ class MyArchitecture: public Architecture {
 
     case lir::Divide:
       if (TargetBytesPerWord == 4 and aSize == 8) {
-        *thunk = true;        			
+        *thunk = true;
       } else {
         aMask.typeMask = (1 << lir::RegisterOperand);
         aMask.registerMask = GeneralRegisterMask & ~((1 << rax) | (1 << rdx));
-        bMask.registerMask = 1 << rax;      
+        bMask.registerMask = 1 << rax;
       }
       break;
 
@@ -764,7 +838,7 @@ class MyArchitecture: public Architecture {
         bMask.registerMask = (static_cast<uint64_t>(mask) << 32) | mask;
       } else {
         aMask.registerMask = (static_cast<uint64_t>(GeneralRegisterMask) << 32)
-          | (static_cast<uint64_t>(1) << rcx);
+                             | (static_cast<uint64_t>(1) << rcx);
         const uint32_t mask = GeneralRegisterMask & ~(1 << rcx);
         bMask.registerMask = (static_cast<uint64_t>(mask) << 32) | mask;
       }
@@ -783,7 +857,7 @@ class MyArchitecture: public Architecture {
       if (useSSE(&c)) {
         aMask.typeMask = (1 << lir::RegisterOperand);
         aMask.registerMask = (static_cast<uint64_t>(FloatRegisterMask) << 32)
-          | FloatRegisterMask;
+                             | FloatRegisterMask;
         bMask.typeMask = aMask.typeMask;
         bMask.registerMask = aMask.registerMask;
       } else {
@@ -796,11 +870,13 @@ class MyArchitecture: public Architecture {
     }
   }
 
-  virtual void planDestination
-  (lir::TernaryOperation op,
-    unsigned, const OperandMask&,
-    unsigned, const OperandMask& bMask,
-    unsigned, OperandMask& cMask)
+  virtual void planDestination(lir::TernaryOperation op,
+                               unsigned,
+                               const OperandMask&,
+                               unsigned,
+                               const OperandMask& bMask,
+                               unsigned,
+                               OperandMask& cMask)
   {
     if (isBranch(op)) {
       cMask.typeMask = (1 << lir::ConstantOperand);
@@ -813,12 +889,14 @@ class MyArchitecture: public Architecture {
 
   virtual Assembler* makeAssembler(util::Allocator* allocator, Zone* zone);
 
-  virtual void acquire() {
-    ++ referenceCount;
+  virtual void acquire()
+  {
+    ++referenceCount;
   }
 
-  virtual void release() {
-    if (-- referenceCount == 0) {
+  virtual void release()
+  {
+    if (--referenceCount == 0) {
       c.s->free(this);
     }
   }
@@ -828,18 +906,21 @@ class MyArchitecture: public Architecture {
   const RegisterFile myRegisterFile;
 };
 
-class MyAssembler: public Assembler {
+class MyAssembler : public Assembler {
  public:
   MyAssembler(System* s, util::Allocator* a, Zone* zone, MyArchitecture* arch)
       : c(s, a, zone, &(arch->c)), arch_(arch)
-  { }
+  {
+  }
 
-  virtual void setClient(Client* client) {
+  virtual void setClient(Client* client)
+  {
     assertT(&c, c.client == 0);
     c.client = client;
   }
 
-  virtual Architecture* arch() {
+  virtual Architecture* arch()
+  {
     return arch_;
   }
 
@@ -849,19 +930,25 @@ class MyAssembler: public Assembler {
     lir::Register stack(rsp);
     lir::Memory stackLimit(rbx, stackLimitOffsetFromThread);
     lir::Constant handlerConstant(resolvedPromise(&c, handler));
-    branchRM(&c, lir::JumpIfGreaterOrEqual, TargetBytesPerWord, &stack, &stackLimit,
+    branchRM(&c,
+             lir::JumpIfGreaterOrEqual,
+             TargetBytesPerWord,
+             &stack,
+             &stackLimit,
              &handlerConstant);
   }
 
-  virtual void saveFrame(unsigned stackOffset, unsigned) {
+  virtual void saveFrame(unsigned stackOffset, unsigned)
+  {
     lir::Register stack(rsp);
     lir::Memory stackDst(rbx, stackOffset);
     apply(lir::Move,
-      OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &stack),
-      OperandInfo(TargetBytesPerWord, lir::MemoryOperand, &stackDst));
+          OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &stack),
+          OperandInfo(TargetBytesPerWord, lir::MemoryOperand, &stackDst));
   }
 
-  virtual void pushFrame(unsigned argumentCount, ...) {
+  virtual void pushFrame(unsigned argumentCount, ...)
+  {
     // TODO: Argument should be replaced by OperandInfo...
     struct Argument {
       unsigned size;
@@ -869,51 +956,51 @@ class MyAssembler: public Assembler {
       lir::Operand* operand;
     };
     RUNTIME_ARRAY(Argument, arguments, argumentCount);
-    va_list a; va_start(a, argumentCount);
+    va_list a;
+    va_start(a, argumentCount);
     unsigned footprint = 0;
     for (unsigned i = 0; i < argumentCount; ++i) {
       RUNTIME_ARRAY_BODY(arguments)[i].size = va_arg(a, unsigned);
       RUNTIME_ARRAY_BODY(arguments)[i].type
-        = static_cast<lir::OperandType>(va_arg(a, int));
+          = static_cast<lir::OperandType>(va_arg(a, int));
       RUNTIME_ARRAY_BODY(arguments)[i].operand = va_arg(a, lir::Operand*);
-      footprint += ceilingDivide
-        (RUNTIME_ARRAY_BODY(arguments)[i].size, TargetBytesPerWord);
+      footprint += ceilingDivide(RUNTIME_ARRAY_BODY(arguments)[i].size,
+                                 TargetBytesPerWord);
     }
     va_end(a);
 
     allocateFrame(arch_->alignFrameSize(footprint));
-    
+
     unsigned offset = 0;
     for (unsigned i = 0; i < argumentCount; ++i) {
       if (i < arch_->argumentRegisterCount()) {
         lir::Register dst(arch_->argumentRegister(i));
         apply(lir::Move,
-              OperandInfo(
-                RUNTIME_ARRAY_BODY(arguments)[i].size,
-                RUNTIME_ARRAY_BODY(arguments)[i].type,
-                RUNTIME_ARRAY_BODY(arguments)[i].operand),
-              OperandInfo(
-                pad(RUNTIME_ARRAY_BODY(arguments)[i].size, TargetBytesPerWord),
-                lir::RegisterOperand,
-                &dst));
+              OperandInfo(RUNTIME_ARRAY_BODY(arguments)[i].size,
+                          RUNTIME_ARRAY_BODY(arguments)[i].type,
+                          RUNTIME_ARRAY_BODY(arguments)[i].operand),
+              OperandInfo(pad(RUNTIME_ARRAY_BODY(arguments)[i].size,
+                              TargetBytesPerWord),
+                          lir::RegisterOperand,
+                          &dst));
       } else {
         lir::Memory dst(rsp, offset * TargetBytesPerWord);
         apply(lir::Move,
-              OperandInfo(
-                RUNTIME_ARRAY_BODY(arguments)[i].size,
-                RUNTIME_ARRAY_BODY(arguments)[i].type,
-                RUNTIME_ARRAY_BODY(arguments)[i].operand),
-              OperandInfo(
-                pad(RUNTIME_ARRAY_BODY(arguments)[i].size, TargetBytesPerWord),
-                lir::MemoryOperand,
-                &dst));
-        offset += ceilingDivide
-          (RUNTIME_ARRAY_BODY(arguments)[i].size, TargetBytesPerWord);
+              OperandInfo(RUNTIME_ARRAY_BODY(arguments)[i].size,
+                          RUNTIME_ARRAY_BODY(arguments)[i].type,
+                          RUNTIME_ARRAY_BODY(arguments)[i].operand),
+              OperandInfo(pad(RUNTIME_ARRAY_BODY(arguments)[i].size,
+                              TargetBytesPerWord),
+                          lir::MemoryOperand,
+                          &dst));
+        offset += ceilingDivide(RUNTIME_ARRAY_BODY(arguments)[i].size,
+                                TargetBytesPerWord);
       }
     }
   }
 
-  virtual void allocateFrame(unsigned footprint) {
+  virtual void allocateFrame(unsigned footprint)
+  {
     lir::Register stack(rsp);
 
     if (UseFramePointer) {
@@ -921,42 +1008,49 @@ class MyAssembler: public Assembler {
       pushR(&c, TargetBytesPerWord, &base);
 
       apply(lir::Move,
-        OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &stack),
-        OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &base));
+            OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &stack),
+            OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &base));
     }
 
-    lir::Constant footprintConstant(resolvedPromise(&c, footprint * TargetBytesPerWord));
+    lir::Constant footprintConstant(
+        resolvedPromise(&c, footprint * TargetBytesPerWord));
     apply(lir::Subtract,
-      OperandInfo(TargetBytesPerWord, lir::ConstantOperand, &footprintConstant),
-      OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &stack),
-      OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &stack));
+          OperandInfo(
+              TargetBytesPerWord, lir::ConstantOperand, &footprintConstant),
+          OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &stack),
+          OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &stack));
   }
 
-  virtual void adjustFrame(unsigned difference) {
+  virtual void adjustFrame(unsigned difference)
+  {
     lir::Register stack(rsp);
-    lir::Constant differenceConstant(resolvedPromise(&c, difference * TargetBytesPerWord));
-    apply(lir::Subtract, 
-      OperandInfo(TargetBytesPerWord, lir::ConstantOperand, &differenceConstant),
-      OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &stack),
-      OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &stack));
+    lir::Constant differenceConstant(
+        resolvedPromise(&c, difference * TargetBytesPerWord));
+    apply(lir::Subtract,
+          OperandInfo(
+              TargetBytesPerWord, lir::ConstantOperand, &differenceConstant),
+          OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &stack),
+          OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &stack));
   }
 
-  virtual void popFrame(unsigned frameFootprint) {
+  virtual void popFrame(unsigned frameFootprint)
+  {
     if (UseFramePointer) {
       lir::Register base(rbp);
       lir::Register stack(rsp);
       apply(lir::Move,
-        OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &base),
-        OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &stack));
+            OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &base),
+            OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &stack));
 
       popR(&c, TargetBytesPerWord, &base);
     } else {
       lir::Register stack(rsp);
-      lir::Constant footprint(resolvedPromise(&c, frameFootprint * TargetBytesPerWord));
+      lir::Constant footprint(
+          resolvedPromise(&c, frameFootprint * TargetBytesPerWord));
       apply(lir::Add,
-        OperandInfo(TargetBytesPerWord, lir::ConstantOperand, &footprint),
-        OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &stack),
-        OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &stack));
+            OperandInfo(TargetBytesPerWord, lir::ConstantOperand, &footprint),
+            OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &stack),
+            OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &stack));
     }
   }
 
@@ -968,17 +1062,23 @@ class MyAssembler: public Assembler {
     if (TailCalls) {
       if (offset) {
         lir::Register tmp(c.client->acquireTemporary());
-      
+
         unsigned baseSize = UseFramePointer ? 1 : 0;
 
-        lir::Memory returnAddressSrc
-          (rsp, (frameFootprint + baseSize) * TargetBytesPerWord);
-        moveMR(&c, TargetBytesPerWord, &returnAddressSrc, TargetBytesPerWord,
+        lir::Memory returnAddressSrc(
+            rsp, (frameFootprint + baseSize) * TargetBytesPerWord);
+        moveMR(&c,
+               TargetBytesPerWord,
+               &returnAddressSrc,
+               TargetBytesPerWord,
                &tmp);
-    
-        lir::Memory returnAddressDst
-          (rsp, (frameFootprint - offset + baseSize) * TargetBytesPerWord);
-        moveRM(&c, TargetBytesPerWord, &tmp, TargetBytesPerWord,
+
+        lir::Memory returnAddressDst(
+            rsp, (frameFootprint - offset + baseSize) * TargetBytesPerWord);
+        moveRM(&c,
+               TargetBytesPerWord,
+               &tmp,
+               TargetBytesPerWord,
                &returnAddressDst);
 
         c.client->releaseTemporary(tmp.low);
@@ -990,9 +1090,8 @@ class MyAssembler: public Assembler {
         }
 
         lir::Register stack(rsp);
-        lir::Constant footprint
-          (resolvedPromise
-           (&c, (frameFootprint - offset + baseSize) * TargetBytesPerWord));
+        lir::Constant footprint(resolvedPromise(
+            &c, (frameFootprint - offset + baseSize) * TargetBytesPerWord));
 
         addCR(&c, TargetBytesPerWord, &footprint, TargetBytesPerWord, &stack);
 
@@ -1032,9 +1131,9 @@ class MyAssembler: public Assembler {
       popR(&c, TargetBytesPerWord, &returnAddress);
 
       lir::Register stack(rsp);
-      lir::Constant adjustment
-        (resolvedPromise(&c, (argumentFootprint - StackAlignmentInWords)
-                  * TargetBytesPerWord));
+      lir::Constant adjustment(resolvedPromise(
+          &c,
+          (argumentFootprint - StackAlignmentInWords) * TargetBytesPerWord));
       addCR(&c, TargetBytesPerWord, &adjustment, TargetBytesPerWord, &stack);
 
       jumpR(&c, TargetBytesPerWord, &returnAddress);
@@ -1058,45 +1157,51 @@ class MyAssembler: public Assembler {
     jumpR(&c, TargetBytesPerWord, &returnAddress);
   }
 
-  virtual void apply(lir::Operation op) {
+  virtual void apply(lir::Operation op)
+  {
     arch_->c.operations[op](&c);
   }
 
   virtual void apply(lir::UnaryOperation op, OperandInfo a)
   {
-    arch_->c.unaryOperations[Multimethod::index(op, a.type)]
-      (&c, a.size, a.operand);
+    arch_->c.unaryOperations[Multimethod::index(op, a.type)](
+        &c, a.size, a.operand);
   }
 
   virtual void apply(lir::BinaryOperation op, OperandInfo a, OperandInfo b)
   {
-    arch_->c.binaryOperations[index(&(arch_->c), op, a.type, b.type)]
-      (&c, a.size, a.operand, b.size, b.operand);
+    arch_->c.binaryOperations[index(&(arch_->c), op, a.type, b.type)](
+        &c, a.size, a.operand, b.size, b.operand);
   }
 
-  virtual void apply(lir::TernaryOperation op, OperandInfo a, OperandInfo b, OperandInfo c)
+  virtual void apply(lir::TernaryOperation op,
+                     OperandInfo a,
+                     OperandInfo b,
+                     OperandInfo c)
   {
     if (isBranch(op)) {
       assertT(&this->c, a.size == b.size);
       assertT(&this->c, c.size == TargetBytesPerWord);
       assertT(&this->c, c.type == lir::ConstantOperand);
 
-      arch_->c.branchOperations[branchIndex(&(arch_->c), a.type, b.type)]
-        (&this->c, op, a.size, a.operand, b.operand, c.operand);
+      arch_->c.branchOperations[branchIndex(&(arch_->c), a.type, b.type)](
+          &this->c, op, a.size, a.operand, b.operand, c.operand);
     } else {
       assertT(&this->c, b.size == c.size);
       assertT(&this->c, b.type == c.type);
 
-      arch_->c.binaryOperations[index(&(arch_->c), op, a.type, b.type)]
-        (&this->c, a.size, a.operand, b.size, b.operand);
+      arch_->c.binaryOperations[index(&(arch_->c), op, a.type, b.type)](
+          &this->c, a.size, a.operand, b.size, b.operand);
     }
   }
 
-  virtual void setDestination(uint8_t* dst) {
+  virtual void setDestination(uint8_t* dst)
+  {
     c.result = dst;
   }
 
-  virtual void write() {
+  virtual void write()
+  {
     uint8_t* dst = c.result;
     for (MyBlock* b = c.firstBlock; b; b = b->next) {
       unsigned index = 0;
@@ -1111,10 +1216,9 @@ class MyAssembler: public Assembler {
         index += size;
 
         while ((b->start + index + padding + p->instructionOffset)
-               % p->alignment)
-        {
+               % p->alignment) {
           *(dst + b->start + index + padding) = 0x90;
-          ++ padding;
+          ++padding;
         }
       }
 
@@ -1122,40 +1226,46 @@ class MyAssembler: public Assembler {
              c.code.data.begin() + b->offset + index,
              b->size - index);
     }
-    
+
     for (Task* t = c.tasks; t; t = t->next) {
       t->run(&c);
     }
   }
 
-  virtual Promise* offset(bool) {
+  virtual Promise* offset(bool)
+  {
     return x86::offsetPromise(&c);
   }
 
-  virtual Block* endBlock(bool startNew) {
+  virtual Block* endBlock(bool startNew)
+  {
     MyBlock* b = c.lastBlock;
     b->size = c.code.length() - b->offset;
     if (startNew) {
-      c.lastBlock = new(c.zone) MyBlock(c.code.length());
+      c.lastBlock = new (c.zone) MyBlock(c.code.length());
     } else {
       c.lastBlock = 0;
     }
     return b;
   }
 
-  virtual void endEvent() {
+  virtual void endEvent()
+  {
     // ignore
   }
 
-  virtual unsigned length() {
+  virtual unsigned length()
+  {
     return c.code.length();
   }
 
-  virtual unsigned footerSize() {
+  virtual unsigned footerSize()
+  {
     return 0;
   }
 
-  virtual void dispose() {
+  virtual void dispose()
+  {
     c.code.dispose();
   }
 
@@ -1165,17 +1275,16 @@ class MyAssembler: public Assembler {
 
 Assembler* MyArchitecture::makeAssembler(util::Allocator* allocator, Zone* zone)
 {
-  return
-    new(zone) MyAssembler(c.s, allocator, zone, this);
+  return new (zone) MyAssembler(c.s, allocator, zone, this);
 }
 
-} // namespace x86
+}  // namespace x86
 
 Architecture* makeArchitectureX86(System* system, bool useNativeFeatures)
 {
   return new (allocate(system, sizeof(x86::MyArchitecture)))
-    x86::MyArchitecture(system, useNativeFeatures);
+      x86::MyArchitecture(system, useNativeFeatures);
 }
 
-} // namespace codegen
-} // namespace avian
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/target/x86/block.cpp b/src/codegen/target/x86/block.cpp
index a506aac932..39169ee9e9 100644
--- a/src/codegen/target/x86/block.cpp
+++ b/src/codegen/target/x86/block.cpp
@@ -16,21 +16,29 @@ namespace avian {
 namespace codegen {
 namespace x86 {
 
-unsigned
-padding(AlignmentPadding* p, unsigned index, unsigned offset, AlignmentPadding* limit);
+unsigned padding(AlignmentPadding* p,
+                 unsigned index,
+                 unsigned offset,
+                 AlignmentPadding* limit);
 
-MyBlock::MyBlock(unsigned offset):
-  next(0), firstPadding(0), lastPadding(0), offset(offset), start(~0),
-  size(0)
-{ }
+MyBlock::MyBlock(unsigned offset)
+    : next(0),
+      firstPadding(0),
+      lastPadding(0),
+      offset(offset),
+      start(~0),
+      size(0)
+{
+}
 
-unsigned MyBlock::resolve(unsigned start, Assembler::Block* next) {
+unsigned MyBlock::resolve(unsigned start, Assembler::Block* next)
+{
   this->start = start;
   this->next = static_cast<MyBlock*>(next);
 
   return start + size + padding(firstPadding, start, offset, lastPadding);
 }
 
-} // namespace x86
-} // namespace codegen
-} // namespace avian
+}  // namespace x86
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/target/x86/block.h b/src/codegen/target/x86/block.h
index 4099ee8122..36e00f68bf 100644
--- a/src/codegen/target/x86/block.h
+++ b/src/codegen/target/x86/block.h
@@ -19,7 +19,7 @@ namespace x86 {
 
 class AlignmentPadding;
 
-class MyBlock: public Assembler::Block {
+class MyBlock : public Assembler::Block {
  public:
   MyBlock(unsigned offset);
 
@@ -33,8 +33,8 @@ class MyBlock: public Assembler::Block {
   unsigned size;
 };
 
-} // namespace x86
-} // namespace codegen
-} // namespace avian
+}  // namespace x86
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_ASSEMBLER_X86_BLOCK_H
+#endif  // AVIAN_CODEGEN_ASSEMBLER_X86_BLOCK_H
diff --git a/src/codegen/target/x86/context.cpp b/src/codegen/target/x86/context.cpp
index 5bd467a74a..93cdef29cd 100644
--- a/src/codegen/target/x86/context.cpp
+++ b/src/codegen/target/x86/context.cpp
@@ -18,9 +18,10 @@ namespace avian {
 namespace codegen {
 namespace x86 {
 
-ArchitectureContext::ArchitectureContext(vm::System* s, bool useNativeFeatures):
-  s(s), useNativeFeatures(useNativeFeatures)
-{ }
+ArchitectureContext::ArchitectureContext(vm::System* s, bool useNativeFeatures)
+    : s(s), useNativeFeatures(useNativeFeatures)
+{
+}
 
 Context::Context(vm::System* s,
                  util::Allocator* a,
@@ -38,6 +39,6 @@ Context::Context(vm::System* s,
 {
 }
 
-} // namespace x86
-} // namespace codegen
-} // namespace avian
+}  // namespace x86
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/target/x86/context.h b/src/codegen/target/x86/context.h
index ddadf7187f..9a1eb912b8 100644
--- a/src/codegen/target/x86/context.h
+++ b/src/codegen/target/x86/context.h
@@ -28,13 +28,13 @@ namespace vm {
 class System;
 class Allocator;
 class Zone;
-} // namespace vm
+}  // namespace vm
 
 namespace avian {
 
 namespace util {
 class Aborter;
-} // namespace util
+}  // namespace util
 
 namespace codegen {
 namespace x86 {
@@ -47,12 +47,18 @@ typedef void (*OperationType)(Context*);
 
 typedef void (*UnaryOperationType)(Context*, unsigned, lir::Operand*);
 
-typedef void (*BinaryOperationType)
-(Context*, unsigned, lir::Operand*, unsigned, lir::Operand*);
+typedef void (*BinaryOperationType)(Context*,
+                                    unsigned,
+                                    lir::Operand*,
+                                    unsigned,
+                                    lir::Operand*);
 
-typedef void (*BranchOperationType)
-(Context*, lir::TernaryOperation, unsigned, lir::Operand*,
- lir::Operand*, lir::Operand*);
+typedef void (*BranchOperationType)(Context*,
+                                    lir::TernaryOperation,
+                                    unsigned,
+                                    lir::Operand*,
+                                    lir::Operand*,
+                                    lir::Operand*);
 
 class ArchitectureContext {
  public:
@@ -61,16 +67,14 @@ class ArchitectureContext {
   vm::System* s;
   bool useNativeFeatures;
   OperationType operations[lir::OperationCount];
-  UnaryOperationType unaryOperations[lir::UnaryOperationCount
-                                     * lir::OperandTypeCount];
+  UnaryOperationType
+      unaryOperations[lir::UnaryOperationCount * lir::OperandTypeCount];
   BinaryOperationType binaryOperations
-  [(lir::BinaryOperationCount + lir::NonBranchTernaryOperationCount)
-   * lir::OperandTypeCount
-   * lir::OperandTypeCount];
-  BranchOperationType branchOperations
-  [lir::BranchOperationCount
-   * lir::OperandTypeCount
-   * lir::OperandTypeCount];
+      [(lir::BinaryOperationCount + lir::NonBranchTernaryOperationCount)
+       * lir::OperandTypeCount * lir::OperandTypeCount];
+  BranchOperationType branchOperations[lir::BranchOperationCount
+                                       * lir::OperandTypeCount
+                                       * lir::OperandTypeCount];
 };
 
 class Context {
@@ -91,16 +95,18 @@ class Context {
   ArchitectureContext* ac;
 };
 
-inline avian::util::Aborter* getAborter(Context* c) {
+inline avian::util::Aborter* getAborter(Context* c)
+{
   return c->s;
 }
 
-inline avian::util::Aborter* getAborter(ArchitectureContext* c) {
+inline avian::util::Aborter* getAborter(ArchitectureContext* c)
+{
   return c->s;
 }
 
-} // namespace x86
-} // namespace codegen
-} // namespace avian
+}  // namespace x86
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_ASSEMBLER_X86_CONTEXT_H
+#endif  // AVIAN_CODEGEN_ASSEMBLER_X86_CONTEXT_H
diff --git a/src/codegen/target/x86/detect.cpp b/src/codegen/target/x86/detect.cpp
index 69ae9f02d2..cfa09cc243 100644
--- a/src/codegen/target/x86/detect.cpp
+++ b/src/codegen/target/x86/detect.cpp
@@ -17,18 +17,18 @@ namespace avian {
 namespace codegen {
 namespace x86 {
 
-extern "C" bool
-detectFeature(unsigned ecx, unsigned edx);
+extern "C" bool detectFeature(unsigned ecx, unsigned edx);
 
-bool useSSE(ArchitectureContext* c) {
+bool useSSE(ArchitectureContext* c)
+{
   if (vm::TargetBytesPerWord == 8) {
     // amd64 implies SSE2 support
     return true;
   } else if (c->useNativeFeatures) {
     static int supported = -1;
     if (supported == -1) {
-      supported = detectFeature(0, 0x2000000) // SSE 1
-        and detectFeature(0, 0x4000000); // SSE 2
+      supported = detectFeature(0, 0x2000000)       // SSE 1
+                  and detectFeature(0, 0x4000000);  // SSE 2
     }
     return supported;
   } else {
@@ -36,6 +36,6 @@ bool useSSE(ArchitectureContext* c) {
   }
 }
 
-} // namespace x86
-} // namespace codegen
-} // namespace avian
+}  // namespace x86
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/target/x86/detect.h b/src/codegen/target/x86/detect.h
index 2a8a46bbbd..1cccb2fd5a 100644
--- a/src/codegen/target/x86/detect.h
+++ b/src/codegen/target/x86/detect.h
@@ -21,8 +21,8 @@ class ArchitectureContext;
 
 bool useSSE(ArchitectureContext* c);
 
-} // namespace x86
-} // namespace codegen
-} // namespace avian
+}  // namespace x86
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_ASSEMBLER_X86_DETECT_H
+#endif  // AVIAN_CODEGEN_ASSEMBLER_X86_DETECT_H
diff --git a/src/codegen/target/x86/encode.cpp b/src/codegen/target/x86/encode.cpp
index 04f2abcdb1..f64d91a2c9 100644
--- a/src/codegen/target/x86/encode.cpp
+++ b/src/codegen/target/x86/encode.cpp
@@ -26,9 +26,8 @@ using namespace avian::util;
 
 namespace {
 
-int64_t
-signExtend(unsigned size, int64_t v)
-{      
+int64_t signExtend(unsigned size, int64_t v)
+{
   if (size == 4) {
     return static_cast<int32_t>(v);
   } else if (size == 2) {
@@ -40,20 +39,25 @@ signExtend(unsigned size, int64_t v)
   }
 }
 
-} // namespace
+}  // namespace
 
 namespace avian {
 namespace codegen {
 namespace x86 {
 
-
 #define REX_W 0x48
 #define REX_R 0x44
 #define REX_X 0x42
 #define REX_B 0x41
 #define REX_NONE 0x40
 
-void maybeRex(Context* c, unsigned size, int a, int index, int base, bool always) {
+void maybeRex(Context* c,
+              unsigned size,
+              int a,
+              int index,
+              int base,
+              bool always)
+{
   if (vm::TargetBytesPerWord == 8) {
     uint8_t byte;
     if (size == 8) {
@@ -61,46 +65,60 @@ void maybeRex(Context* c, unsigned size, int a, int index, int base, bool always
     } else {
       byte = REX_NONE;
     }
-    if (a != lir::NoRegister and (a & 8)) byte |= REX_R;
-    if (index != lir::NoRegister and (index & 8)) byte |= REX_X;
-    if (base != lir::NoRegister and (base & 8)) byte |= REX_B;
-    if (always or byte != REX_NONE) c->code.append(byte);
+    if (a != lir::NoRegister and (a & 8))
+      byte |= REX_R;
+    if (index != lir::NoRegister and (index & 8))
+      byte |= REX_X;
+    if (base != lir::NoRegister and (base & 8))
+      byte |= REX_B;
+    if (always or byte != REX_NONE)
+      c->code.append(byte);
   }
 }
 
-void maybeRex(Context* c, unsigned size, lir::Register* a, lir::Register* b) {
+void maybeRex(Context* c, unsigned size, lir::Register* a, lir::Register* b)
+{
   maybeRex(c, size, a->low, lir::NoRegister, b->low, false);
 }
 
-void alwaysRex(Context* c, unsigned size, lir::Register* a, lir::Register* b) {
+void alwaysRex(Context* c, unsigned size, lir::Register* a, lir::Register* b)
+{
   maybeRex(c, size, a->low, lir::NoRegister, b->low, true);
 }
 
-void maybeRex(Context* c, unsigned size, lir::Register* a) {
+void maybeRex(Context* c, unsigned size, lir::Register* a)
+{
   maybeRex(c, size, lir::NoRegister, lir::NoRegister, a->low, false);
 }
 
-void maybeRex(Context* c, unsigned size, lir::Register* a, lir::Memory* b) {
+void maybeRex(Context* c, unsigned size, lir::Register* a, lir::Memory* b)
+{
   maybeRex(c, size, a->low, b->index, b->base, size == 1 and (a->low & 4));
 }
 
-void maybeRex(Context* c, unsigned size, lir::Memory* a) {
+void maybeRex(Context* c, unsigned size, lir::Memory* a)
+{
   maybeRex(c, size, lir::NoRegister, a->index, a->base, false);
 }
 
-void modrm(Context* c, uint8_t mod, int a, int b) {
+void modrm(Context* c, uint8_t mod, int a, int b)
+{
   c->code.append(mod | (regCode(b) << 3) | regCode(a));
 }
 
-void modrm(Context* c, uint8_t mod, lir::Register* a, lir::Register* b) {
+void modrm(Context* c, uint8_t mod, lir::Register* a, lir::Register* b)
+{
   modrm(c, mod, a->low, b->low);
 }
 
-void sib(Context* c, unsigned scale, int index, int base) {
-  c->code.append((util::log(scale) << 6) | (regCode(index) << 3) | regCode(base));
+void sib(Context* c, unsigned scale, int index, int base)
+{
+  c->code.append((util::log(scale) << 6) | (regCode(index) << 3)
+                 | regCode(base));
 }
 
-void modrmSib(Context* c, int width, int a, int scale, int index, int base) {
+void modrmSib(Context* c, int width, int a, int scale, int index, int base)
+{
   if (index == lir::NoRegister) {
     modrm(c, width, base, a);
     if (regCode(base) == rsp) {
@@ -112,7 +130,8 @@ void modrmSib(Context* c, int width, int a, int scale, int index, int base) {
   }
 }
 
-void modrmSibImm(Context* c, int a, int scale, int index, int base, int offset) {
+void modrmSibImm(Context* c, int a, int scale, int index, int base, int offset)
+{
   if (offset == 0 and regCode(base) != rbp) {
     modrmSib(c, 0x00, a, scale, index, base);
   } else if (vm::fitsInInt8(offset)) {
@@ -124,35 +143,43 @@ void modrmSibImm(Context* c, int a, int scale, int index, int base, int offset)
   }
 }
 
-void modrmSibImm(Context* c, lir::Register* a, lir::Memory* b) {
+void modrmSibImm(Context* c, lir::Register* a, lir::Memory* b)
+{
   modrmSibImm(c, a->low, b->scale, b->index, b->base, b->offset);
 }
 
-void opcode(Context* c, uint8_t op) {
+void opcode(Context* c, uint8_t op)
+{
   c->code.append(op);
 }
 
-void opcode(Context* c, uint8_t op1, uint8_t op2) {
+void opcode(Context* c, uint8_t op1, uint8_t op2)
+{
   c->code.append(op1);
   c->code.append(op2);
 }
 
-void unconditional(Context* c, unsigned jump, lir::Constant* a) {
+void unconditional(Context* c, unsigned jump, lir::Constant* a)
+{
   appendOffsetTask(c, a->value, offsetPromise(c), 5);
 
   opcode(c, jump);
   c->code.append4(0);
 }
 
-void conditional(Context* c, unsigned condition, lir::Constant* a) {
+void conditional(Context* c, unsigned condition, lir::Constant* a)
+{
   appendOffsetTask(c, a->value, offsetPromise(c), 6);
-  
+
   opcode(c, 0x0f, condition);
   c->code.append4(0);
 }
 
-void sseMoveRR(Context* c, unsigned aSize, lir::Register* a,
-          unsigned bSize UNUSED, lir::Register* b)
+void sseMoveRR(Context* c,
+               unsigned aSize,
+               lir::Register* a,
+               unsigned bSize UNUSED,
+               lir::Register* b)
 {
   assertT(c, aSize >= 4);
   assertT(c, aSize == bSize);
@@ -168,22 +195,25 @@ void sseMoveRR(Context* c, unsigned aSize, lir::Register* a,
       maybeRex(c, 4, b, a);
       opcode(c, 0x0f, 0x10);
       modrm(c, 0xc0, a, b);
-    } 
+    }
   } else if (isFloatReg(a)) {
     opcode(c, 0x66);
     maybeRex(c, aSize, a, b);
     opcode(c, 0x0f, 0x7e);
-    modrm(c, 0xc0, b, a);   
+    modrm(c, 0xc0, b, a);
   } else {
     opcode(c, 0x66);
     maybeRex(c, aSize, b, a);
     opcode(c, 0x0f, 0x6e);
-    modrm(c, 0xc0, a, b);   
+    modrm(c, 0xc0, a, b);
   }
 }
 
-void sseMoveCR(Context* c, unsigned aSize, lir::Constant* a,
-          unsigned bSize, lir::Register* b)
+void sseMoveCR(Context* c,
+               unsigned aSize,
+               lir::Constant* a,
+               unsigned bSize,
+               lir::Register* b)
 {
   assertT(c, aSize <= vm::TargetBytesPerWord);
   lir::Register tmp(c->client->acquireTemporary(GeneralRegisterMask));
@@ -192,8 +222,11 @@ void sseMoveCR(Context* c, unsigned aSize, lir::Constant* a,
   c->client->releaseTemporary(tmp.low);
 }
 
-void sseMoveMR(Context* c, unsigned aSize, lir::Memory* a,
-          unsigned bSize UNUSED, lir::Register* b)
+void sseMoveMR(Context* c,
+               unsigned aSize,
+               lir::Memory* a,
+               unsigned bSize UNUSED,
+               lir::Register* b)
 {
   assertT(c, aSize >= 4);
 
@@ -209,8 +242,11 @@ void sseMoveMR(Context* c, unsigned aSize, lir::Memory* a,
   }
 }
 
-void sseMoveRM(Context* c, unsigned aSize, lir::Register* a,
-       UNUSED unsigned bSize, lir::Memory* b)
+void sseMoveRM(Context* c,
+               unsigned aSize,
+               lir::Register* a,
+               UNUSED unsigned bSize,
+               lir::Memory* b)
 {
   assertT(c, aSize >= 4);
   assertT(c, aSize == bSize);
@@ -227,7 +263,8 @@ void sseMoveRM(Context* c, unsigned aSize, lir::Register* a,
   }
 }
 
-void branch(Context* c, lir::TernaryOperation op, lir::Constant* target) {
+void branch(Context* c, lir::TernaryOperation op, lir::Constant* target)
+{
   switch (op) {
   case lir::JumpIfEqual:
     conditional(c, 0x84, target);
@@ -258,7 +295,8 @@ void branch(Context* c, lir::TernaryOperation op, lir::Constant* target) {
   }
 }
 
-void branchFloat(Context* c, lir::TernaryOperation op, lir::Constant* target) {
+void branchFloat(Context* c, lir::TernaryOperation op, lir::Constant* target)
+{
   switch (op) {
   case lir::JumpIfFloatEqual:
     // jp past the je so we don't jump to the target if unordered:
@@ -313,8 +351,13 @@ void branchFloat(Context* c, lir::TernaryOperation op, lir::Constant* target) {
   }
 }
 
-void floatRegOp(Context* c, unsigned aSize, lir::Register* a, unsigned bSize,
-           lir::Register* b, uint8_t op, uint8_t mod)
+void floatRegOp(Context* c,
+                unsigned aSize,
+                lir::Register* a,
+                unsigned bSize,
+                lir::Register* b,
+                uint8_t op,
+                uint8_t mod)
 {
   if (aSize == 4) {
     opcode(c, 0xf3);
@@ -326,8 +369,12 @@ void floatRegOp(Context* c, unsigned aSize, lir::Register* a, unsigned bSize,
   modrm(c, mod, a, b);
 }
 
-void floatMemOp(Context* c, unsigned aSize, lir::Memory* a, unsigned bSize,
-           lir::Register* b, uint8_t op)
+void floatMemOp(Context* c,
+                unsigned aSize,
+                lir::Memory* a,
+                unsigned bSize,
+                lir::Register* b,
+                uint8_t op)
 {
   if (aSize == 4) {
     opcode(c, 0xf3);
@@ -339,11 +386,18 @@ void floatMemOp(Context* c, unsigned aSize, lir::Memory* a, unsigned bSize,
   modrmSibImm(c, b, a);
 }
 
-void moveCR(Context* c, unsigned aSize, lir::Constant* a,
-       unsigned bSize, lir::Register* b);
+void moveCR(Context* c,
+            unsigned aSize,
+            lir::Constant* a,
+            unsigned bSize,
+            lir::Register* b);
 
-void moveCR2(Context* c, UNUSED unsigned aSize, lir::Constant* a,
-        UNUSED unsigned bSize, lir::Register* b, unsigned promiseOffset)
+void moveCR2(Context* c,
+             UNUSED unsigned aSize,
+             lir::Constant* a,
+             UNUSED unsigned bSize,
+             lir::Register* b,
+             unsigned promiseOffset)
 {
   if (vm::TargetBytesPerWord == 4 and bSize == 8) {
     int64_t v = signExtend(aSize, a->value->value());
@@ -366,13 +420,13 @@ void moveCR2(Context* c, UNUSED unsigned aSize, lir::Constant* a,
     } else {
       expect(c, aSize == vm::TargetBytesPerWord);
 
-      appendImmediateTask
-        (c, a->value, offsetPromise(c), vm::TargetBytesPerWord, promiseOffset);
+      appendImmediateTask(
+          c, a->value, offsetPromise(c), vm::TargetBytesPerWord, promiseOffset);
       c->code.appendTargetAddress(static_cast<vm::target_uintptr_t>(0));
     }
   }
 }
 
-} // namespace x86
-} // namespace codegen
-} // namespace avian
+}  // namespace x86
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/target/x86/encode.h b/src/codegen/target/x86/encode.h
index 2b067ae2da..564b84f6e9 100644
--- a/src/codegen/target/x86/encode.h
+++ b/src/codegen/target/x86/encode.h
@@ -25,7 +25,12 @@ namespace x86 {
 
 class Context;
 
-void maybeRex(Context* c, unsigned size, int a, int index, int base, bool always);
+void maybeRex(Context* c,
+              unsigned size,
+              int a,
+              int index,
+              int base,
+              bool always);
 
 void maybeRex(Context* c, unsigned size, lir::Register* a, lir::Register* b);
 
@@ -37,15 +42,18 @@ void maybeRex(Context* c, unsigned size, lir::Register* a, lir::Memory* b);
 
 void maybeRex(Context* c, unsigned size, lir::Memory* a);
 
-inline int regCode(int a) {
+inline int regCode(int a)
+{
   return a & 7;
 }
 
-inline int regCode(lir::Register* a) {
+inline int regCode(lir::Register* a)
+{
   return regCode(a->low);
 }
 
-inline bool isFloatReg(lir::Register* a) {
+inline bool isFloatReg(lir::Register* a)
+{
   return a->low >= xmm0;
 }
 
@@ -58,7 +66,7 @@ void sib(Context* c, unsigned scale, int index, int base);
 void modrmSib(Context* c, int width, int a, int scale, int index, int base);
 
 void modrmSibImm(Context* c, int a, int scale, int index, int base, int offset);
-  
+
 void modrmSibImm(Context* c, lir::Register* a, lir::Memory* b);
 
 void opcode(Context* c, uint8_t op);
@@ -69,33 +77,58 @@ void unconditional(Context* c, unsigned jump, lir::Constant* a);
 
 void conditional(Context* c, unsigned condition, lir::Constant* a);
 
-void sseMoveRR(Context* c, unsigned aSize, lir::Register* a,
-          unsigned bSize UNUSED, lir::Register* b);
+void sseMoveRR(Context* c,
+               unsigned aSize,
+               lir::Register* a,
+               unsigned bSize UNUSED,
+               lir::Register* b);
 
-void sseMoveCR(Context* c, unsigned aSize, lir::Constant* a,
-          unsigned bSize, lir::Register* b);
+void sseMoveCR(Context* c,
+               unsigned aSize,
+               lir::Constant* a,
+               unsigned bSize,
+               lir::Register* b);
 
-void sseMoveMR(Context* c, unsigned aSize, lir::Memory* a,
-          unsigned bSize UNUSED, lir::Register* b);
+void sseMoveMR(Context* c,
+               unsigned aSize,
+               lir::Memory* a,
+               unsigned bSize UNUSED,
+               lir::Register* b);
 
-void sseMoveRM(Context* c, unsigned aSize, lir::Register* a,
-       UNUSED unsigned bSize, lir::Memory* b);
+void sseMoveRM(Context* c,
+               unsigned aSize,
+               lir::Register* a,
+               UNUSED unsigned bSize,
+               lir::Memory* b);
 
 void branch(Context* c, lir::TernaryOperation op, lir::Constant* target);
 
 void branchFloat(Context* c, lir::TernaryOperation op, lir::Constant* target);
 
-void floatRegOp(Context* c, unsigned aSize, lir::Register* a, unsigned bSize,
-           lir::Register* b, uint8_t op, uint8_t mod = 0xc0);
+void floatRegOp(Context* c,
+                unsigned aSize,
+                lir::Register* a,
+                unsigned bSize,
+                lir::Register* b,
+                uint8_t op,
+                uint8_t mod = 0xc0);
 
-void floatMemOp(Context* c, unsigned aSize, lir::Memory* a, unsigned bSize,
-           lir::Register* b, uint8_t op);
+void floatMemOp(Context* c,
+                unsigned aSize,
+                lir::Memory* a,
+                unsigned bSize,
+                lir::Register* b,
+                uint8_t op);
 
-void moveCR2(Context* c, UNUSED unsigned aSize, lir::Constant* a,
-        UNUSED unsigned bSize, lir::Register* b, unsigned promiseOffset);
+void moveCR2(Context* c,
+             UNUSED unsigned aSize,
+             lir::Constant* a,
+             UNUSED unsigned bSize,
+             lir::Register* b,
+             unsigned promiseOffset);
 
-} // namespace x86
-} // namespace codegen
-} // namespace avian
+}  // namespace x86
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_ASSEMBLER_X86_ENCODE_H
+#endif  // AVIAN_CODEGEN_ASSEMBLER_X86_ENCODE_H
diff --git a/src/codegen/target/x86/fixup.cpp b/src/codegen/target/x86/fixup.cpp
index 8e32669a5b..dbf53628e3 100644
--- a/src/codegen/target/x86/fixup.cpp
+++ b/src/codegen/target/x86/fixup.cpp
@@ -29,39 +29,49 @@ namespace x86 {
 
 using namespace util;
 
-ResolvedPromise* resolvedPromise(Context* c, int64_t value) {
-  return new(c->zone) ResolvedPromise(value);
+ResolvedPromise* resolvedPromise(Context* c, int64_t value)
+{
+  return new (c->zone) ResolvedPromise(value);
 }
 
-OffsetPromise::OffsetPromise(Context* c, MyBlock* block, unsigned offset, AlignmentPadding* limit):
-  c(c), block(block), offset(offset), limit(limit), value_(-1)
-{ }
+OffsetPromise::OffsetPromise(Context* c,
+                             MyBlock* block,
+                             unsigned offset,
+                             AlignmentPadding* limit)
+    : c(c), block(block), offset(offset), limit(limit), value_(-1)
+{
+}
 
-bool OffsetPromise::resolved() {
+bool OffsetPromise::resolved()
+{
   return block->start != static_cast<unsigned>(~0);
 }
 
-int64_t OffsetPromise::value() {
+int64_t OffsetPromise::value()
+{
   assertT(c, resolved());
 
   if (value_ == -1) {
     value_ = block->start + (offset - block->offset)
-      + padding(block->firstPadding, block->start, block->offset, limit);
+             + padding(block->firstPadding, block->start, block->offset, limit);
   }
 
   return value_;
 }
-Promise* offsetPromise(Context* c) {
-  return new(c->zone) OffsetPromise(c, c->lastBlock, c->code.length(), c->lastBlock->lastPadding);
+Promise* offsetPromise(Context* c)
+{
+  return new (c->zone) OffsetPromise(
+      c, c->lastBlock, c->code.length(), c->lastBlock->lastPadding);
 }
 
-void*
-resolveOffset(vm::System* s, uint8_t* instruction, unsigned instructionSize,
-              int64_t value)
+void* resolveOffset(vm::System* s,
+                    uint8_t* instruction,
+                    unsigned instructionSize,
+                    int64_t value)
 {
-  intptr_t v = reinterpret_cast<uint8_t*>(value)
-    - instruction - instructionSize;
-    
+  intptr_t v = reinterpret_cast<uint8_t*>(value) - instruction
+               - instructionSize;
+
   expect(s, vm::fitsInInt32(v));
 
   int32_t v4 = v;
@@ -69,54 +79,66 @@ resolveOffset(vm::System* s, uint8_t* instruction, unsigned instructionSize,
   return instruction + instructionSize;
 }
 
-OffsetListener::OffsetListener(vm::System* s, uint8_t* instruction,
-               unsigned instructionSize):
-  s(s),
-  instruction(instruction),
-  instructionSize(instructionSize)
-{ }
+OffsetListener::OffsetListener(vm::System* s,
+                               uint8_t* instruction,
+                               unsigned instructionSize)
+    : s(s), instruction(instruction), instructionSize(instructionSize)
+{
+}
 
-bool OffsetListener::resolve(int64_t value, void** location) {
+bool OffsetListener::resolve(int64_t value, void** location)
+{
   void* p = resolveOffset(s, instruction, instructionSize, value);
-  if (location) *location = p;
+  if (location)
+    *location = p;
   return false;
 }
 
-OffsetTask::OffsetTask(Task* next, Promise* promise, Promise* instructionOffset,
-           unsigned instructionSize):
-  Task(next),
-  promise(promise),
-  instructionOffset(instructionOffset),
-  instructionSize(instructionSize)
-{ }
+OffsetTask::OffsetTask(Task* next,
+                       Promise* promise,
+                       Promise* instructionOffset,
+                       unsigned instructionSize)
+    : Task(next),
+      promise(promise),
+      instructionOffset(instructionOffset),
+      instructionSize(instructionSize)
+{
+}
 
-void OffsetTask::run(Context* c) {
+void OffsetTask::run(Context* c)
+{
   if (promise->resolved()) {
-    resolveOffset
-      (c->s, c->result + instructionOffset->value(), instructionSize,
-       promise->value());
+    resolveOffset(c->s,
+                  c->result + instructionOffset->value(),
+                  instructionSize,
+                  promise->value());
   } else {
-    new (promise->listen(sizeof(OffsetListener)))
-      OffsetListener(c->s, c->result + instructionOffset->value(),
-                     instructionSize);
+    new (promise->listen(sizeof(OffsetListener))) OffsetListener(
+        c->s, c->result + instructionOffset->value(), instructionSize);
   }
 }
 
-void
-appendOffsetTask(Context* c, Promise* promise, Promise* instructionOffset,
-                 unsigned instructionSize)
+void appendOffsetTask(Context* c,
+                      Promise* promise,
+                      Promise* instructionOffset,
+                      unsigned instructionSize)
 {
-  OffsetTask* task =
-    new(c->zone) OffsetTask(c->tasks, promise, instructionOffset, instructionSize);
+  OffsetTask* task = new (c->zone)
+      OffsetTask(c->tasks, promise, instructionOffset, instructionSize);
 
   c->tasks = task;
 }
 
-ImmediateListener::ImmediateListener(vm::System* s, void* dst, unsigned size, unsigned offset):
-  s(s), dst(dst), size(size), offset(offset)
-{ }
+ImmediateListener::ImmediateListener(vm::System* s,
+                                     void* dst,
+                                     unsigned size,
+                                     unsigned offset)
+    : s(s), dst(dst), size(size), offset(offset)
+{
+}
 
-void copy(vm::System* s, void* dst, int64_t src, unsigned size) {
+void copy(vm::System* s, void* dst, int64_t src, unsigned size)
+{
   switch (size) {
   case 4: {
     int32_t v = src;
@@ -128,46 +150,60 @@ void copy(vm::System* s, void* dst, int64_t src, unsigned size) {
     memcpy(dst, &v, 8);
   } break;
 
-  default: abort(s);
+  default:
+    abort(s);
   }
 }
 
-bool ImmediateListener::resolve(int64_t value, void** location) {
+bool ImmediateListener::resolve(int64_t value, void** location)
+{
   copy(s, dst, value, size);
-  if (location) *location = static_cast<uint8_t*>(dst) + offset;
+  if (location)
+    *location = static_cast<uint8_t*>(dst) + offset;
   return offset == 0;
 }
 
-ImmediateTask::ImmediateTask(Task* next, Promise* promise, Promise* offset, unsigned size,
-              unsigned promiseOffset):
-  Task(next),
-  promise(promise),
-  offset(offset),
-  size(size),
-  promiseOffset(promiseOffset)
-{ }
+ImmediateTask::ImmediateTask(Task* next,
+                             Promise* promise,
+                             Promise* offset,
+                             unsigned size,
+                             unsigned promiseOffset)
+    : Task(next),
+      promise(promise),
+      offset(offset),
+      size(size),
+      promiseOffset(promiseOffset)
+{
+}
 
-void ImmediateTask::run(Context* c) {
+void ImmediateTask::run(Context* c)
+{
   if (promise->resolved()) {
     copy(c->s, c->result + offset->value(), promise->value(), size);
   } else {
-    new (promise->listen(sizeof(ImmediateListener))) ImmediateListener
-      (c->s, c->result + offset->value(), size, promiseOffset);
+    new (promise->listen(sizeof(ImmediateListener))) ImmediateListener(
+        c->s, c->result + offset->value(), size, promiseOffset);
   }
 }
 
-void
-appendImmediateTask(Context* c, Promise* promise, Promise* offset,
-                    unsigned size, unsigned promiseOffset)
+void appendImmediateTask(Context* c,
+                         Promise* promise,
+                         Promise* offset,
+                         unsigned size,
+                         unsigned promiseOffset)
 {
-  c->tasks = new(c->zone) ImmediateTask
-    (c->tasks, promise, offset, size, promiseOffset);
+  c->tasks = new (c->zone)
+      ImmediateTask(c->tasks, promise, offset, size, promiseOffset);
 }
 
-ShiftMaskPromise* shiftMaskPromise(Context* c, Promise* base, unsigned shift, int64_t mask) {
-  return new(c->zone) ShiftMaskPromise(base, shift, mask);
+ShiftMaskPromise* shiftMaskPromise(Context* c,
+                                   Promise* base,
+                                   unsigned shift,
+                                   int64_t mask)
+{
+  return new (c->zone) ShiftMaskPromise(base, shift, mask);
 }
 
-} // namespace x86
-} // namespace codegen
-} // namespace avian
+}  // namespace x86
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/target/x86/fixup.h b/src/codegen/target/x86/fixup.h
index 13d0ac7103..1796ab44e9 100644
--- a/src/codegen/target/x86/fixup.h
+++ b/src/codegen/target/x86/fixup.h
@@ -31,19 +31,24 @@ ResolvedPromise* resolvedPromise(Context* c, int64_t value);
 
 class Task {
  public:
-  Task(Task* next): next(next) { }
+  Task(Task* next) : next(next)
+  {
+  }
 
   virtual void run(Context* c) = 0;
 
   Task* next;
 };
 
-class OffsetPromise: public Promise {
+class OffsetPromise : public Promise {
  public:
-  OffsetPromise(Context* c, MyBlock* block, unsigned offset, AlignmentPadding* limit);
+  OffsetPromise(Context* c,
+                MyBlock* block,
+                unsigned offset,
+                AlignmentPadding* limit);
 
   virtual bool resolved();
-  
+
   virtual int64_t value();
 
   Context* c;
@@ -55,9 +60,12 @@ class OffsetPromise: public Promise {
 
 Promise* offsetPromise(Context* c);
 
-void* resolveOffset(vm::System* s, uint8_t* instruction, unsigned instructionSize, int64_t value);
+void* resolveOffset(vm::System* s,
+                    uint8_t* instruction,
+                    unsigned instructionSize,
+                    int64_t value);
 
-class OffsetListener: public Promise::Listener {
+class OffsetListener : public Promise::Listener {
  public:
   OffsetListener(vm::System* s, uint8_t* instruction, unsigned instructionSize);
 
@@ -68,9 +76,12 @@ class OffsetListener: public Promise::Listener {
   unsigned instructionSize;
 };
 
-class OffsetTask: public Task {
+class OffsetTask : public Task {
  public:
-  OffsetTask(Task* next, Promise* promise, Promise* instructionOffset, unsigned instructionSize);
+  OffsetTask(Task* next,
+             Promise* promise,
+             Promise* instructionOffset,
+             unsigned instructionSize);
 
   virtual void run(Context* c);
 
@@ -79,9 +90,12 @@ class OffsetTask: public Task {
   unsigned instructionSize;
 };
 
-void appendOffsetTask(Context* c, Promise* promise, Promise* instructionOffset, unsigned instructionSize);
+void appendOffsetTask(Context* c,
+                      Promise* promise,
+                      Promise* instructionOffset,
+                      unsigned instructionSize);
 
-class ImmediateListener: public Promise::Listener {
+class ImmediateListener : public Promise::Listener {
  public:
   ImmediateListener(vm::System* s, void* dst, unsigned size, unsigned offset);
 
@@ -93,9 +107,12 @@ class ImmediateListener: public Promise::Listener {
   unsigned offset;
 };
 
-class ImmediateTask: public Task {
+class ImmediateTask : public Task {
  public:
-  ImmediateTask(Task* next, Promise* promise, Promise* offset, unsigned size,
+  ImmediateTask(Task* next,
+                Promise* promise,
+                Promise* offset,
+                unsigned size,
                 unsigned promiseOffset);
 
   virtual void run(Context* c);
@@ -106,14 +123,19 @@ class ImmediateTask: public Task {
   unsigned promiseOffset;
 };
 
-void
-appendImmediateTask(Context* c, Promise* promise, Promise* offset,
-                    unsigned size, unsigned promiseOffset = 0);
+void appendImmediateTask(Context* c,
+                         Promise* promise,
+                         Promise* offset,
+                         unsigned size,
+                         unsigned promiseOffset = 0);
 
-ShiftMaskPromise* shiftMaskPromise(Context* c, Promise* base, unsigned shift, int64_t mask);
+ShiftMaskPromise* shiftMaskPromise(Context* c,
+                                   Promise* base,
+                                   unsigned shift,
+                                   int64_t mask);
 
-} // namespace x86
-} // namespace codegen
-} // namespace avian
+}  // namespace x86
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_ASSEMBLER_X86_FIXUP_H
+#endif  // AVIAN_CODEGEN_ASSEMBLER_X86_FIXUP_H
diff --git a/src/codegen/target/x86/multimethod.cpp b/src/codegen/target/x86/multimethod.cpp
index d72da5483f..19e6135e1a 100644
--- a/src/codegen/target/x86/multimethod.cpp
+++ b/src/codegen/target/x86/multimethod.cpp
@@ -26,35 +26,40 @@ namespace x86 {
 
 using namespace util;
 
-unsigned index(ArchitectureContext*, lir::BinaryOperation operation,
-      lir::OperandType operand1,
-      lir::OperandType operand2)
+unsigned index(ArchitectureContext*,
+               lir::BinaryOperation operation,
+               lir::OperandType operand1,
+               lir::OperandType operand2)
 {
-  return operation
-    + ((lir::BinaryOperationCount + lir::NonBranchTernaryOperationCount) * operand1)
-    + ((lir::BinaryOperationCount + lir::NonBranchTernaryOperationCount)
-       * lir::OperandTypeCount * operand2);
+  return operation + ((lir::BinaryOperationCount
+                       + lir::NonBranchTernaryOperationCount) * operand1)
+         + ((lir::BinaryOperationCount + lir::NonBranchTernaryOperationCount)
+            * lir::OperandTypeCount * operand2);
 }
 
-unsigned index(ArchitectureContext* c UNUSED, lir::TernaryOperation operation,
-      lir::OperandType operand1, lir::OperandType operand2)
+unsigned index(ArchitectureContext* c UNUSED,
+               lir::TernaryOperation operation,
+               lir::OperandType operand1,
+               lir::OperandType operand2)
 {
   assertT(c, not isBranch(operation));
 
   return lir::BinaryOperationCount + operation
-    + ((lir::BinaryOperationCount + lir::NonBranchTernaryOperationCount) * operand1)
-    + ((lir::BinaryOperationCount + lir::NonBranchTernaryOperationCount)
-       * lir::OperandTypeCount * operand2);
+         + ((lir::BinaryOperationCount + lir::NonBranchTernaryOperationCount)
+            * operand1)
+         + ((lir::BinaryOperationCount + lir::NonBranchTernaryOperationCount)
+            * lir::OperandTypeCount * operand2);
 }
 
-unsigned branchIndex(ArchitectureContext* c UNUSED, lir::OperandType operand1,
-            lir::OperandType operand2)
+unsigned branchIndex(ArchitectureContext* c UNUSED,
+                     lir::OperandType operand1,
+                     lir::OperandType operand2)
 {
   return operand1 + (lir::OperandTypeCount * operand2);
 }
 
-
-void populateTables(ArchitectureContext* c) {
+void populateTables(ArchitectureContext* c)
+{
   const lir::OperandType C = lir::ConstantOperand;
   const lir::OperandType A = lir::AddressOperand;
   const lir::OperandType R = lir::RegisterOperand;
@@ -170,6 +175,6 @@ void populateTables(ArchitectureContext* c) {
   bro[branchIndex(c, R, M)] = CAST_BRANCH(branchRM);
 }
 
-} // namespace x86
-} // namespace codegen
-} // namespace avian
+}  // namespace x86
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/target/x86/multimethod.h b/src/codegen/target/x86/multimethod.h
index 58056926b9..e9a4b36de6 100644
--- a/src/codegen/target/x86/multimethod.h
+++ b/src/codegen/target/x86/multimethod.h
@@ -21,20 +21,24 @@ namespace x86 {
 
 class ArchitectureContext;
 
-unsigned index(ArchitectureContext*, lir::BinaryOperation operation,
-      lir::OperandType operand1,
-      lir::OperandType operand2);
+unsigned index(ArchitectureContext*,
+               lir::BinaryOperation operation,
+               lir::OperandType operand1,
+               lir::OperandType operand2);
 
-unsigned index(ArchitectureContext* c UNUSED, lir::TernaryOperation operation,
-      lir::OperandType operand1, lir::OperandType operand2);
+unsigned index(ArchitectureContext* c UNUSED,
+               lir::TernaryOperation operation,
+               lir::OperandType operand1,
+               lir::OperandType operand2);
 
-unsigned branchIndex(ArchitectureContext* c UNUSED, lir::OperandType operand1,
-            lir::OperandType operand2);
+unsigned branchIndex(ArchitectureContext* c UNUSED,
+                     lir::OperandType operand1,
+                     lir::OperandType operand2);
 
 void populateTables(ArchitectureContext* c);
 
-} // namespace x86
-} // namespace codegen
-} // namespace avian
+}  // namespace x86
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_ASSEMBLER_X86_MULTIMETHOD_H
+#endif  // AVIAN_CODEGEN_ASSEMBLER_X86_MULTIMETHOD_H
diff --git a/src/codegen/target/x86/operations.cpp b/src/codegen/target/x86/operations.cpp
index 85f12cac00..0301cda1eb 100644
--- a/src/codegen/target/x86/operations.cpp
+++ b/src/codegen/target/x86/operations.cpp
@@ -32,17 +32,22 @@ namespace avian {
 namespace codegen {
 namespace x86 {
 
-void return_(Context* c) {
+void return_(Context* c)
+{
   opcode(c, 0xc3);
 }
 
-void trap(Context* c) {
+void trap(Context* c)
+{
   opcode(c, 0xcc);
 }
 
-void ignore(Context*) { }
+void ignore(Context*)
+{
+}
 
-void storeLoadBarrier(Context* c) {
+void storeLoadBarrier(Context* c)
+{
   if (useSSE(c->ac)) {
     // mfence:
     c->code.append(0x0f);
@@ -57,17 +62,19 @@ void storeLoadBarrier(Context* c) {
     c->code.append(0x83);
     c->code.append(0x04);
     c->code.append(0x24);
-    c->code.append(0x00);    
+    c->code.append(0x00);
   }
 }
 
-void callC(Context* c, unsigned size UNUSED, lir::Constant* a) {
+void callC(Context* c, unsigned size UNUSED, lir::Constant* a)
+{
   assertT(c, size == vm::TargetBytesPerWord);
 
   unconditional(c, 0xe8, a);
 }
 
-void longCallC(Context* c, unsigned size, lir::Constant* a) {
+void longCallC(Context* c, unsigned size, lir::Constant* a)
+{
   assertT(c, size == vm::TargetBytesPerWord);
 
   if (vm::TargetBytesPerWord == 8) {
@@ -79,20 +86,23 @@ void longCallC(Context* c, unsigned size, lir::Constant* a) {
   }
 }
 
-void jumpR(Context* c, unsigned size UNUSED, lir::Register* a) {
+void jumpR(Context* c, unsigned size UNUSED, lir::Register* a)
+{
   assertT(c, size == vm::TargetBytesPerWord);
 
   maybeRex(c, 4, a);
   opcode(c, 0xff, 0xe0 + regCode(a));
 }
 
-void jumpC(Context* c, unsigned size UNUSED, lir::Constant* a) {
+void jumpC(Context* c, unsigned size UNUSED, lir::Constant* a)
+{
   assertT(c, size == vm::TargetBytesPerWord);
 
   unconditional(c, 0xe9, a);
 }
 
-void jumpM(Context* c, unsigned size UNUSED, lir::Memory* a) {
+void jumpM(Context* c, unsigned size UNUSED, lir::Memory* a)
+{
   assertT(c, size == vm::TargetBytesPerWord);
 
   maybeRex(c, 4, a);
@@ -100,7 +110,8 @@ void jumpM(Context* c, unsigned size UNUSED, lir::Memory* a) {
   modrmSibImm(c, rsp, a->scale, a->index, a->base, a->offset);
 }
 
-void longJumpC(Context* c, unsigned size, lir::Constant* a) {
+void longJumpC(Context* c, unsigned size, lir::Constant* a)
+{
   assertT(c, size == vm::TargetBytesPerWord);
 
   if (vm::TargetBytesPerWord == 8) {
@@ -112,7 +123,8 @@ void longJumpC(Context* c, unsigned size, lir::Constant* a) {
   }
 }
 
-void callR(Context* c, unsigned size UNUSED, lir::Register* a) {
+void callR(Context* c, unsigned size UNUSED, lir::Register* a)
+{
   assertT(c, size == vm::TargetBytesPerWord);
 
   // maybeRex.W has no meaning here so we disable it
@@ -120,7 +132,8 @@ void callR(Context* c, unsigned size UNUSED, lir::Register* a) {
   opcode(c, 0xff, 0xd0 + regCode(a));
 }
 
-void callM(Context* c, unsigned size UNUSED, lir::Memory* a) {
+void callM(Context* c, unsigned size UNUSED, lir::Memory* a)
+{
   assertT(c, size == vm::TargetBytesPerWord);
 
   maybeRex(c, 4, a);
@@ -128,12 +141,14 @@ void callM(Context* c, unsigned size UNUSED, lir::Memory* a) {
   modrmSibImm(c, rdx, a->scale, a->index, a->base, a->offset);
 }
 
-void alignedCallC(Context* c, unsigned size, lir::Constant* a) {
-  new(c->zone) AlignmentPadding(c, 1, 4);
+void alignedCallC(Context* c, unsigned size, lir::Constant* a)
+{
+  new (c->zone) AlignmentPadding(c, 1, 4);
   callC(c, size, a);
 }
 
-void alignedLongCallC(Context* c, unsigned size, lir::Constant* a) {
+void alignedLongCallC(Context* c, unsigned size, lir::Constant* a)
+{
   assertT(c, size == vm::TargetBytesPerWord);
 
   if (vm::TargetBytesPerWord == 8) {
@@ -144,12 +159,14 @@ void alignedLongCallC(Context* c, unsigned size, lir::Constant* a) {
   }
 }
 
-void alignedJumpC(Context* c, unsigned size, lir::Constant* a) {
+void alignedJumpC(Context* c, unsigned size, lir::Constant* a)
+{
   new (c->zone) AlignmentPadding(c, 1, 4);
   jumpC(c, size, a);
 }
 
-void alignedLongJumpC(Context* c, unsigned size, lir::Constant* a) {
+void alignedLongJumpC(Context* c, unsigned size, lir::Constant* a)
+{
   assertT(c, size == vm::TargetBytesPerWord);
 
   if (vm::TargetBytesPerWord == 8) {
@@ -208,16 +225,22 @@ void negateR(Context* c, unsigned size, lir::Register* a)
   }
 }
 
-void negateRR(Context* c, unsigned aSize, lir::Register* a,
-         unsigned bSize UNUSED, lir::Register* b UNUSED)
+void negateRR(Context* c,
+              unsigned aSize,
+              lir::Register* a,
+              unsigned bSize UNUSED,
+              lir::Register* b UNUSED)
 {
   assertT(c, aSize == bSize);
 
   negateR(c, aSize, a);
 }
 
-void moveCR(Context* c, unsigned aSize, lir::Constant* a,
-       unsigned bSize, lir::Register* b)
+void moveCR(Context* c,
+            unsigned aSize,
+            lir::Constant* a,
+            unsigned bSize,
+            lir::Register* b)
 {
   if (isFloatReg(b)) {
     sseMoveCR(c, aSize, a, bSize, b);
@@ -226,8 +249,11 @@ void moveCR(Context* c, unsigned aSize, lir::Constant* a,
   }
 }
 
-void moveZCR(Context* c, unsigned aSize UNUSED, lir::Constant* a,
-             unsigned bSize UNUSED, lir::Register* b)
+void moveZCR(Context* c,
+             unsigned aSize UNUSED,
+             lir::Constant* a,
+             unsigned bSize UNUSED,
+             lir::Register* b)
 {
   assertT(c, not isFloatReg(b));
   assertT(c, aSize == 2);
@@ -239,8 +265,11 @@ void moveZCR(Context* c, unsigned aSize UNUSED, lir::Constant* a,
   c->code.appendTargetAddress(static_cast<uint16_t>(a->value->value()));
 }
 
-void swapRR(Context* c, unsigned aSize UNUSED, lir::Register* a,
-       unsigned bSize UNUSED, lir::Register* b)
+void swapRR(Context* c,
+            unsigned aSize UNUSED,
+            lir::Register* a,
+            unsigned bSize UNUSED,
+            lir::Register* b)
 {
   assertT(c, aSize == bSize);
   assertT(c, aSize == vm::TargetBytesPerWord);
@@ -250,14 +279,17 @@ void swapRR(Context* c, unsigned aSize UNUSED, lir::Register* a,
   modrm(c, 0xc0, b, a);
 }
 
-void moveRR(Context* c, unsigned aSize, lir::Register* a,
-       UNUSED unsigned bSize, lir::Register* b)
+void moveRR(Context* c,
+            unsigned aSize,
+            lir::Register* a,
+            UNUSED unsigned bSize,
+            lir::Register* b)
 {
   if (isFloatReg(a) or isFloatReg(b)) {
     sseMoveRR(c, aSize, a, bSize, b);
     return;
   }
-  
+
   if (vm::TargetBytesPerWord == 4 and aSize == 8 and bSize == 8) {
     lir::Register ah(a->high);
     lir::Register bh(b->high);
@@ -302,7 +334,7 @@ void moveRR(Context* c, unsigned aSize, lir::Register* a,
           modrm(c, 0xc0, a, b);
         } else {
           if (a->low == rax and b->low == rax and b->high == rdx) {
-            opcode(c, 0x99); //cdq
+            opcode(c, 0x99);  // cdq
           } else {
             assertT(c, b->low == rax and b->high == rdx);
 
@@ -317,10 +349,10 @@ void moveRR(Context* c, unsigned aSize, lir::Register* a,
           modrm(c, 0xc0, b, a);
         }
       }
-      break; 
-      
+      break;
+
     case 8:
-      if (a->low != b->low){
+      if (a->low != b->low) {
         maybeRex(c, aSize, a, b);
         opcode(c, 0x89);
         modrm(c, 0xc0, b, a);
@@ -330,14 +362,17 @@ void moveRR(Context* c, unsigned aSize, lir::Register* a,
   }
 }
 
-void moveMR(Context* c, unsigned aSize, lir::Memory* a,
-       unsigned bSize, lir::Register* b)
+void moveMR(Context* c,
+            unsigned aSize,
+            lir::Memory* a,
+            unsigned bSize,
+            lir::Register* b)
 {
   if (isFloatReg(b)) {
     sseMoveMR(c, aSize, a, bSize, b);
     return;
   }
-  
+
   switch (aSize) {
   case 1:
     maybeRex(c, bSize, b, a);
@@ -369,13 +404,13 @@ void moveMR(Context* c, unsigned aSize, lir::Memory* a,
       }
     }
     break;
-    
+
   case 8:
     if (vm::TargetBytesPerWord == 4 and bSize == 8) {
       lir::Memory ah(a->base, a->offset + 4, a->index, a->scale);
       lir::Register bh(b->high);
 
-      moveMR(c, 4, a, 4, b);    
+      moveMR(c, 4, a, 4, b);
       moveMR(c, 4, &ah, 4, &bh);
     } else {
       maybeRex(c, bSize, b, a);
@@ -384,12 +419,16 @@ void moveMR(Context* c, unsigned aSize, lir::Memory* a,
     }
     break;
 
-  default: abort(c);
+  default:
+    abort(c);
   }
 }
 
-void moveRM(Context* c, unsigned aSize, lir::Register* a,
-       unsigned bSize UNUSED, lir::Memory* b)
+void moveRM(Context* c,
+            unsigned aSize,
+            lir::Register* a,
+            unsigned bSize UNUSED,
+            lir::Memory* b)
 {
   assertT(c, aSize == bSize);
 
@@ -397,7 +436,7 @@ void moveRM(Context* c, unsigned aSize, lir::Register* a,
     sseMoveRM(c, aSize, a, bSize, b);
     return;
   }
-  
+
   switch (aSize) {
   case 1:
     maybeRex(c, bSize, a, b);
@@ -423,7 +462,7 @@ void moveRM(Context* c, unsigned aSize, lir::Register* a,
       modrmSibImm(c, a, b);
     }
     break;
-    
+
   case 8:
     if (vm::TargetBytesPerWord == 8) {
       maybeRex(c, bSize, a, b);
@@ -433,17 +472,21 @@ void moveRM(Context* c, unsigned aSize, lir::Register* a,
       lir::Register ah(a->high);
       lir::Memory bh(b->base, b->offset + 4, b->index, b->scale);
 
-      moveRM(c, 4, a, 4, b);    
+      moveRM(c, 4, a, 4, b);
       moveRM(c, 4, &ah, 4, &bh);
     }
     break;
 
-  default: abort(c);
+  default:
+    abort(c);
   }
 }
 
-void moveAR(Context* c, unsigned aSize, lir::Address* a,
-       unsigned bSize, lir::Register* b)
+void moveAR(Context* c,
+            unsigned aSize,
+            lir::Address* a,
+            unsigned bSize,
+            lir::Register* b)
 {
   assertT(c, vm::TargetBytesPerWord == 8 or (aSize == 4 and bSize == 4));
 
@@ -454,8 +497,11 @@ void moveAR(Context* c, unsigned aSize, lir::Address* a,
   moveMR(c, bSize, &memory, bSize, b);
 }
 
-void moveCM(Context* c, unsigned aSize UNUSED, lir::Constant* a,
-       unsigned bSize, lir::Memory* b)
+void moveCM(Context* c,
+            unsigned aSize UNUSED,
+            lir::Constant* a,
+            unsigned bSize,
+            lir::Memory* b)
 {
   switch (bSize) {
   case 1:
@@ -493,8 +539,7 @@ void moveCM(Context* c, unsigned aSize UNUSED, lir::Constant* a,
         modrmSibImm(c, 0, b->scale, b->index, b->base, b->offset);
         c->code.append4(a->value->value());
       } else {
-        lir::Register tmp
-          (c->client->acquireTemporary(GeneralRegisterMask));
+        lir::Register tmp(c->client->acquireTemporary(GeneralRegisterMask));
         moveCR(c, 8, a, 8, &tmp);
         moveRM(c, 8, &tmp, 8, b);
         c->client->releaseTemporary(tmp.low);
@@ -510,12 +555,16 @@ void moveCM(Context* c, unsigned aSize UNUSED, lir::Constant* a,
     }
   } break;
 
-  default: abort(c);
+  default:
+    abort(c);
   }
 }
 
-void moveZRR(Context* c, unsigned aSize, lir::Register* a,
-        unsigned bSize UNUSED, lir::Register* b)
+void moveZRR(Context* c,
+             unsigned aSize,
+             lir::Register* a,
+             unsigned bSize UNUSED,
+             lir::Register* b)
 {
   switch (aSize) {
   case 2:
@@ -524,12 +573,16 @@ void moveZRR(Context* c, unsigned aSize, lir::Register* a,
     modrm(c, 0xc0, a, b);
     break;
 
-  default: abort(c);
+  default:
+    abort(c);
   }
 }
 
-void moveZMR(Context* c, unsigned aSize UNUSED, lir::Memory* a,
-        unsigned bSize UNUSED, lir::Register* b)
+void moveZMR(Context* c,
+             unsigned aSize UNUSED,
+             lir::Memory* a,
+             unsigned bSize UNUSED,
+             lir::Register* b)
 {
   assertT(c, bSize == vm::TargetBytesPerWord);
   assertT(c, aSize == 2);
@@ -539,8 +592,7 @@ void moveZMR(Context* c, unsigned aSize UNUSED, lir::Memory* a,
   modrmSibImm(c, b->low, a->scale, a->index, a->base, a->offset);
 }
 
-void addCarryRR(Context* c, unsigned size, lir::Register* a,
-           lir::Register* b)
+void addCarryRR(Context* c, unsigned size, lir::Register* a, lir::Register* b)
 {
   assertT(c, vm::TargetBytesPerWord == 8 or size == 4);
 
@@ -549,8 +601,11 @@ void addCarryRR(Context* c, unsigned size, lir::Register* a,
   modrm(c, 0xc0, b, a);
 }
 
-void addRR(Context* c, unsigned aSize, lir::Register* a,
-      unsigned bSize UNUSED, lir::Register* b)
+void addRR(Context* c,
+           unsigned aSize,
+           lir::Register* a,
+           unsigned bSize UNUSED,
+           lir::Register* b)
 {
   assertT(c, aSize == bSize);
 
@@ -567,10 +622,8 @@ void addRR(Context* c, unsigned aSize, lir::Register* a,
   }
 }
 
-void addCarryCR(Context* c, unsigned size, lir::Constant* a,
-           lir::Register* b)
+void addCarryCR(Context* c, unsigned size, lir::Constant* a, lir::Register* b)
 {
-  
   int64_t v = a->value->value();
   maybeRex(c, size, b);
   if (vm::fitsInInt8(v)) {
@@ -582,8 +635,11 @@ void addCarryCR(Context* c, unsigned size, lir::Constant* a,
   }
 }
 
-void addCR(Context* c, unsigned aSize, lir::Constant* a,
-      unsigned bSize, lir::Register* b)
+void addCR(Context* c,
+           unsigned aSize,
+           lir::Constant* a,
+           unsigned bSize,
+           lir::Register* b)
 {
   assertT(c, aSize == bSize);
 
@@ -611,8 +667,7 @@ void addCR(Context* c, unsigned aSize, lir::Constant* a,
           c->code.append4(v);
         }
       } else {
-        lir::Register tmp
-          (c->client->acquireTemporary(GeneralRegisterMask));
+        lir::Register tmp(c->client->acquireTemporary(GeneralRegisterMask));
         moveCR(c, aSize, a, aSize, &tmp);
         addRR(c, aSize, &tmp, bSize, b);
         c->client->releaseTemporary(tmp.low);
@@ -621,8 +676,10 @@ void addCR(Context* c, unsigned aSize, lir::Constant* a,
   }
 }
 
-void subtractBorrowCR(Context* c, unsigned size UNUSED, lir::Constant* a,
-                 lir::Register* b)
+void subtractBorrowCR(Context* c,
+                      unsigned size UNUSED,
+                      lir::Constant* a,
+                      lir::Register* b)
 {
   assertT(c, vm::TargetBytesPerWord == 8 or size == 4);
 
@@ -636,8 +693,11 @@ void subtractBorrowCR(Context* c, unsigned size UNUSED, lir::Constant* a,
   }
 }
 
-void subtractCR(Context* c, unsigned aSize, lir::Constant* a,
-           unsigned bSize, lir::Register* b)
+void subtractCR(Context* c,
+                unsigned aSize,
+                lir::Constant* a,
+                unsigned bSize,
+                lir::Register* b)
 {
   assertT(c, aSize == bSize);
 
@@ -665,8 +725,7 @@ void subtractCR(Context* c, unsigned aSize, lir::Constant* a,
           c->code.append4(v);
         }
       } else {
-        lir::Register tmp
-          (c->client->acquireTemporary(GeneralRegisterMask));
+        lir::Register tmp(c->client->acquireTemporary(GeneralRegisterMask));
         moveCR(c, aSize, a, aSize, &tmp);
         subtractRR(c, aSize, &tmp, bSize, b);
         c->client->releaseTemporary(tmp.low);
@@ -675,8 +734,10 @@ void subtractCR(Context* c, unsigned aSize, lir::Constant* a,
   }
 }
 
-void subtractBorrowRR(Context* c, unsigned size, lir::Register* a,
-                 lir::Register* b)
+void subtractBorrowRR(Context* c,
+                      unsigned size,
+                      lir::Register* a,
+                      lir::Register* b)
 {
   assertT(c, vm::TargetBytesPerWord == 8 or size == 4);
 
@@ -685,8 +746,11 @@ void subtractBorrowRR(Context* c, unsigned size, lir::Register* a,
   modrm(c, 0xc0, b, a);
 }
 
-void subtractRR(Context* c, unsigned aSize, lir::Register* a,
-           unsigned bSize UNUSED, lir::Register* b)
+void subtractRR(Context* c,
+                unsigned aSize,
+                lir::Register* a,
+                unsigned bSize UNUSED,
+                lir::Register* b)
 {
   assertT(c, aSize == bSize);
 
@@ -703,8 +767,11 @@ void subtractRR(Context* c, unsigned aSize, lir::Register* a,
   }
 }
 
-void andRR(Context* c, unsigned aSize, lir::Register* a,
-      unsigned bSize UNUSED, lir::Register* b)
+void andRR(Context* c,
+           unsigned aSize,
+           lir::Register* a,
+           unsigned bSize UNUSED,
+           lir::Register* b)
 {
   assertT(c, aSize == bSize);
 
@@ -721,8 +788,11 @@ void andRR(Context* c, unsigned aSize, lir::Register* a,
   }
 }
 
-void andCR(Context* c, unsigned aSize, lir::Constant* a,
-      unsigned bSize, lir::Register* b)
+void andCR(Context* c,
+           unsigned aSize,
+           lir::Constant* a,
+           unsigned bSize,
+           lir::Register* b)
 {
   assertT(c, aSize == bSize);
 
@@ -750,8 +820,7 @@ void andCR(Context* c, unsigned aSize, lir::Constant* a,
         c->code.append4(v);
       }
     } else {
-      lir::Register tmp
-        (c->client->acquireTemporary(GeneralRegisterMask));
+      lir::Register tmp(c->client->acquireTemporary(GeneralRegisterMask));
       moveCR(c, aSize, a, aSize, &tmp);
       andRR(c, aSize, &tmp, bSize, b);
       c->client->releaseTemporary(tmp.low);
@@ -759,8 +828,11 @@ void andCR(Context* c, unsigned aSize, lir::Constant* a,
   }
 }
 
-void orRR(Context* c, unsigned aSize, lir::Register* a,
-     unsigned bSize UNUSED, lir::Register* b)
+void orRR(Context* c,
+          unsigned aSize,
+          lir::Register* a,
+          unsigned bSize UNUSED,
+          lir::Register* b)
 {
   assertT(c, aSize == bSize);
 
@@ -777,8 +849,11 @@ void orRR(Context* c, unsigned aSize, lir::Register* a,
   }
 }
 
-void orCR(Context* c, unsigned aSize, lir::Constant* a,
-     unsigned bSize, lir::Register* b)
+void orCR(Context* c,
+          unsigned aSize,
+          lir::Constant* a,
+          unsigned bSize,
+          lir::Register* b)
 {
   assertT(c, aSize == bSize);
 
@@ -803,11 +878,10 @@ void orCR(Context* c, unsigned aSize, lir::Constant* a,
           c->code.append(v);
         } else {
           opcode(c, 0x81, 0xc8 + regCode(b));
-          c->code.append4(v);        
+          c->code.append4(v);
         }
       } else {
-        lir::Register tmp
-          (c->client->acquireTemporary(GeneralRegisterMask));
+        lir::Register tmp(c->client->acquireTemporary(GeneralRegisterMask));
         moveCR(c, aSize, a, aSize, &tmp);
         orRR(c, aSize, &tmp, bSize, b);
         c->client->releaseTemporary(tmp.low);
@@ -816,8 +890,11 @@ void orCR(Context* c, unsigned aSize, lir::Constant* a,
   }
 }
 
-void xorRR(Context* c, unsigned aSize, lir::Register* a,
-      unsigned bSize UNUSED, lir::Register* b)
+void xorRR(Context* c,
+           unsigned aSize,
+           lir::Register* a,
+           unsigned bSize UNUSED,
+           lir::Register* b)
 {
   if (vm::TargetBytesPerWord == 4 and aSize == 8) {
     lir::Register ah(a->high);
@@ -832,8 +909,11 @@ void xorRR(Context* c, unsigned aSize, lir::Register* a,
   }
 }
 
-void xorCR(Context* c, unsigned aSize, lir::Constant* a,
-      unsigned bSize, lir::Register* b)
+void xorCR(Context* c,
+           unsigned aSize,
+           lir::Constant* a,
+           unsigned bSize,
+           lir::Register* b)
 {
   assertT(c, aSize == bSize);
 
@@ -858,11 +938,10 @@ void xorCR(Context* c, unsigned aSize, lir::Constant* a,
           c->code.append(v);
         } else {
           opcode(c, 0x81, 0xf0 + regCode(b));
-          c->code.append4(v);        
+          c->code.append4(v);
         }
       } else {
-        lir::Register tmp
-          (c->client->acquireTemporary(GeneralRegisterMask));
+        lir::Register tmp(c->client->acquireTemporary(GeneralRegisterMask));
         moveCR(c, aSize, a, aSize, &tmp);
         xorRR(c, aSize, &tmp, bSize, b);
         c->client->releaseTemporary(tmp.low);
@@ -871,8 +950,11 @@ void xorCR(Context* c, unsigned aSize, lir::Constant* a,
   }
 }
 
-void multiplyRR(Context* c, unsigned aSize, lir::Register* a,
-           unsigned bSize UNUSED, lir::Register* b)
+void multiplyRR(Context* c,
+                unsigned aSize,
+                lir::Register* a,
+                unsigned bSize UNUSED,
+                lir::Register* b)
 {
   assertT(c, aSize == bSize);
 
@@ -891,8 +973,7 @@ void multiplyRR(Context* c, unsigned aSize, lir::Register* a,
     lir::Register tmp(-1);
     lir::Register* scratch;
     if (a->low == b->low) {
-      tmp.low = c->client->acquireTemporary
-        (GeneralRegisterMask & ~(1 << rax));
+      tmp.low = c->client->acquireTemporary(GeneralRegisterMask & ~(1 << rax));
       scratch = &tmp;
       moveRR(c, 4, b, 4, scratch);
     } else {
@@ -903,10 +984,10 @@ void multiplyRR(Context* c, unsigned aSize, lir::Register* a,
     multiplyRR(c, 4, &ah, 4, scratch);
     multiplyRR(c, 4, a, 4, &bh);
     addRR(c, 4, &bh, 4, scratch);
-    
+
     // mul a->low,%eax%edx
     opcode(c, 0xf7, 0xe0 + a->low);
-    
+
     addRR(c, 4, scratch, 4, &bh);
     moveRR(c, 4, &axdx, 4, b);
 
@@ -920,19 +1001,25 @@ void multiplyRR(Context* c, unsigned aSize, lir::Register* a,
   }
 }
 
-void compareRR(Context* c, unsigned aSize, lir::Register* a,
-          unsigned bSize UNUSED, lir::Register* b)
+void compareRR(Context* c,
+               unsigned aSize,
+               lir::Register* a,
+               unsigned bSize UNUSED,
+               lir::Register* b)
 {
   assertT(c, aSize == bSize);
   assertT(c, aSize <= vm::TargetBytesPerWord);
 
   maybeRex(c, aSize, a, b);
   opcode(c, 0x39);
-  modrm(c, 0xc0, b, a);  
+  modrm(c, 0xc0, b, a);
 }
 
-void compareCR(Context* c, unsigned aSize, lir::Constant* a,
-          unsigned bSize, lir::Register* b)
+void compareCR(Context* c,
+               unsigned aSize,
+               lir::Constant* a,
+               unsigned bSize,
+               lir::Register* b)
 {
   assertT(c, aSize == bSize);
   assertT(c, vm::TargetBytesPerWord == 8 or aSize == 4);
@@ -955,8 +1042,11 @@ void compareCR(Context* c, unsigned aSize, lir::Constant* a,
   }
 }
 
-void compareRM(Context* c, unsigned aSize, lir::Register* a,
-          unsigned bSize UNUSED, lir::Memory* b)
+void compareRM(Context* c,
+               unsigned aSize,
+               lir::Register* a,
+               unsigned bSize UNUSED,
+               lir::Memory* b)
 {
   assertT(c, aSize == bSize);
   assertT(c, vm::TargetBytesPerWord == 8 or aSize == 4);
@@ -969,18 +1059,21 @@ void compareRM(Context* c, unsigned aSize, lir::Register* a,
   modrmSibImm(c, a, b);
 }
 
-void compareCM(Context* c, unsigned aSize, lir::Constant* a,
-          unsigned bSize, lir::Memory* b)
+void compareCM(Context* c,
+               unsigned aSize,
+               lir::Constant* a,
+               unsigned bSize,
+               lir::Memory* b)
 {
   assertT(c, aSize == bSize);
   assertT(c, vm::TargetBytesPerWord == 8 or aSize == 4);
 
-  if (a->value->resolved()) { 
-    int64_t v = a->value->value();   
+  if (a->value->resolved()) {
+    int64_t v = a->value->value();
     maybeRex(c, aSize, b);
     opcode(c, vm::fitsInInt8(v) ? 0x83 : 0x81);
     modrmSibImm(c, rdi, b->scale, b->index, b->base, b->offset);
-    
+
     if (vm::fitsInInt8(v)) {
       c->code.append(v);
     } else if (vm::fitsInInt32(v)) {
@@ -996,8 +1089,11 @@ void compareCM(Context* c, unsigned aSize, lir::Constant* a,
   }
 }
 
-void compareFloatRR(Context* c, unsigned aSize, lir::Register* a,
-               unsigned bSize UNUSED, lir::Register* b)
+void compareFloatRR(Context* c,
+                    unsigned aSize,
+                    lir::Register* a,
+                    unsigned bSize UNUSED,
+                    lir::Register* b)
 {
   assertT(c, aSize == bSize);
 
@@ -1009,79 +1105,83 @@ void compareFloatRR(Context* c, unsigned aSize, lir::Register* a,
   modrm(c, 0xc0, a, b);
 }
 
-void branchLong(Context* c, lir::TernaryOperation op, lir::Operand* al,
-           lir::Operand* ah, lir::Operand* bl,
-           lir::Operand* bh, lir::Constant* target,
-           BinaryOperationType compare)
+void branchLong(Context* c,
+                lir::TernaryOperation op,
+                lir::Operand* al,
+                lir::Operand* ah,
+                lir::Operand* bl,
+                lir::Operand* bh,
+                lir::Constant* target,
+                BinaryOperationType compare)
 {
   compare(c, 4, ah, 4, bh);
-  
+
   unsigned next = 0;
 
   switch (op) {
   case lir::JumpIfEqual:
-    opcode(c, 0x75); // jne
+    opcode(c, 0x75);  // jne
     next = c->code.length();
     c->code.append(0);
 
     compare(c, 4, al, 4, bl);
-    conditional(c, 0x84, target); // je
+    conditional(c, 0x84, target);  // je
     break;
 
   case lir::JumpIfNotEqual:
-    conditional(c, 0x85, target); // jne
+    conditional(c, 0x85, target);  // jne
 
     compare(c, 4, al, 4, bl);
-    conditional(c, 0x85, target); // jne
+    conditional(c, 0x85, target);  // jne
     break;
 
   case lir::JumpIfLess:
-    conditional(c, 0x8c, target); // jl
+    conditional(c, 0x8c, target);  // jl
 
-    opcode(c, 0x7f); // jg
+    opcode(c, 0x7f);  // jg
     next = c->code.length();
     c->code.append(0);
 
     compare(c, 4, al, 4, bl);
-    conditional(c, 0x82, target); // jb
+    conditional(c, 0x82, target);  // jb
     break;
 
   case lir::JumpIfGreater:
-    conditional(c, 0x8f, target); // jg
+    conditional(c, 0x8f, target);  // jg
 
-    opcode(c, 0x7c); // jl
+    opcode(c, 0x7c);  // jl
     next = c->code.length();
     c->code.append(0);
 
     compare(c, 4, al, 4, bl);
-    conditional(c, 0x87, target); // ja
+    conditional(c, 0x87, target);  // ja
     break;
 
   case lir::JumpIfLessOrEqual:
-    conditional(c, 0x8c, target); // jl
+    conditional(c, 0x8c, target);  // jl
 
-    opcode(c, 0x7f); // jg
+    opcode(c, 0x7f);  // jg
     next = c->code.length();
     c->code.append(0);
 
     compare(c, 4, al, 4, bl);
-    conditional(c, 0x86, target); // jbe
+    conditional(c, 0x86, target);  // jbe
     break;
 
   case lir::JumpIfGreaterOrEqual:
-    conditional(c, 0x8f, target); // jg
+    conditional(c, 0x8f, target);  // jg
 
-    opcode(c, 0x7c); // jl
+    opcode(c, 0x7c);  // jl
     next = c->code.length();
     c->code.append(0);
 
     compare(c, 4, al, 4, bl);
-    conditional(c, 0x83, target); // jae
+    conditional(c, 0x83, target);  // jae
     break;
 
   default:
     abort(c);
-  }  
+  }
 
   if (next) {
     int8_t nextOffset = c->code.length() - next - 1;
@@ -1089,9 +1189,12 @@ void branchLong(Context* c, lir::TernaryOperation op, lir::Operand* al,
   }
 }
 
-void branchRR(Context* c, lir::TernaryOperation op, unsigned size,
-         lir::Register* a, lir::Register* b,
-         lir::Constant* target)
+void branchRR(Context* c,
+              lir::TernaryOperation op,
+              unsigned size,
+              lir::Register* a,
+              lir::Register* b,
+              lir::Constant* target)
 {
   if (isFloatBranch(op)) {
     compareFloatRR(c, size, a, size, b);
@@ -1107,9 +1210,12 @@ void branchRR(Context* c, lir::TernaryOperation op, unsigned size,
   }
 }
 
-void branchCR(Context* c, lir::TernaryOperation op, unsigned size,
-         lir::Constant* a, lir::Register* b,
-         lir::Constant* target)
+void branchCR(Context* c,
+              lir::TernaryOperation op,
+              unsigned size,
+              lir::Constant* a,
+              lir::Register* b,
+              lir::Constant* target)
 {
   assertT(c, not isFloatBranch(op));
 
@@ -1118,10 +1224,10 @@ void branchCR(Context* c, lir::TernaryOperation op, unsigned size,
 
     ResolvedPromise low(v & ~static_cast<uintptr_t>(0));
     lir::Constant al(&low);
-  
+
     ResolvedPromise high((v >> 32) & ~static_cast<uintptr_t>(0));
     lir::Constant ah(&high);
-  
+
     lir::Register bh(b->high);
 
     branchLong(c, op, &al, &ah, b, &bh, target, CAST2(compareCR));
@@ -1131,9 +1237,12 @@ void branchCR(Context* c, lir::TernaryOperation op, unsigned size,
   }
 }
 
-void branchRM(Context* c, lir::TernaryOperation op, unsigned size,
-         lir::Register* a, lir::Memory* b,
-         lir::Constant* target)
+void branchRM(Context* c,
+              lir::TernaryOperation op,
+              unsigned size,
+              lir::Register* a,
+              lir::Memory* b,
+              lir::Constant* target)
 {
   assertT(c, not isFloatBranch(op));
   assertT(c, size <= vm::TargetBytesPerWord);
@@ -1142,9 +1251,12 @@ void branchRM(Context* c, lir::TernaryOperation op, unsigned size,
   branch(c, op, target);
 }
 
-void branchCM(Context* c, lir::TernaryOperation op, unsigned size,
-         lir::Constant* a, lir::Memory* b,
-         lir::Constant* target)
+void branchCM(Context* c,
+              lir::TernaryOperation op,
+              unsigned size,
+              lir::Constant* a,
+              lir::Memory* b,
+              lir::Constant* target)
 {
   assertT(c, not isFloatBranch(op));
   assertT(c, size <= vm::TargetBytesPerWord);
@@ -1153,15 +1265,18 @@ void branchCM(Context* c, lir::TernaryOperation op, unsigned size,
   branch(c, op, target);
 }
 
-void multiplyCR(Context* c, unsigned aSize, lir::Constant* a,
-           unsigned bSize, lir::Register* b)
+void multiplyCR(Context* c,
+                unsigned aSize,
+                lir::Constant* a,
+                unsigned bSize,
+                lir::Register* b)
 {
   assertT(c, aSize == bSize);
 
   if (vm::TargetBytesPerWord == 4 and aSize == 8) {
     const uint32_t mask = GeneralRegisterMask & ~((1 << rax) | (1 << rdx));
     lir::Register tmp(c->client->acquireTemporary(mask),
-                            c->client->acquireTemporary(mask));
+                      c->client->acquireTemporary(mask));
 
     moveCR(c, aSize, a, aSize, &tmp);
     multiplyRR(c, aSize, &tmp, bSize, b);
@@ -1179,21 +1294,23 @@ void multiplyCR(Context* c, unsigned aSize, lir::Constant* a,
         } else {
           opcode(c, 0x69);
           modrm(c, 0xc0, b, b);
-          c->code.append4(v);        
+          c->code.append4(v);
         }
       } else {
-        lir::Register tmp
-          (c->client->acquireTemporary(GeneralRegisterMask));
+        lir::Register tmp(c->client->acquireTemporary(GeneralRegisterMask));
         moveCR(c, aSize, a, aSize, &tmp);
         multiplyRR(c, aSize, &tmp, bSize, b);
-        c->client->releaseTemporary(tmp.low);      
+        c->client->releaseTemporary(tmp.low);
       }
     }
   }
 }
 
-void divideRR(Context* c, unsigned aSize, lir::Register* a,
-         unsigned bSize UNUSED, lir::Register* b UNUSED)
+void divideRR(Context* c,
+              unsigned aSize,
+              lir::Register* a,
+              unsigned bSize UNUSED,
+              lir::Register* b UNUSED)
 {
   assertT(c, aSize == bSize);
 
@@ -1202,14 +1319,17 @@ void divideRR(Context* c, unsigned aSize, lir::Register* a,
 
   c->client->save(rdx);
 
-  maybeRex(c, aSize, a, b);    
-  opcode(c, 0x99); // cdq
+  maybeRex(c, aSize, a, b);
+  opcode(c, 0x99);  // cdq
   maybeRex(c, aSize, b, a);
   opcode(c, 0xf7, 0xf8 + regCode(a));
 }
 
-void remainderRR(Context* c, unsigned aSize, lir::Register* a,
-            unsigned bSize UNUSED, lir::Register* b)
+void remainderRR(Context* c,
+                 unsigned aSize,
+                 lir::Register* a,
+                 unsigned bSize UNUSED,
+                 lir::Register* b)
 {
   assertT(c, aSize == bSize);
 
@@ -1218,8 +1338,8 @@ void remainderRR(Context* c, unsigned aSize, lir::Register* a,
 
   c->client->save(rdx);
 
-  maybeRex(c, aSize, a, b);    
-  opcode(c, 0x99); // cdq
+  maybeRex(c, aSize, a, b);
+  opcode(c, 0x99);  // cdq
   maybeRex(c, aSize, b, a);
   opcode(c, 0xf7, 0xf8 + regCode(a));
 
@@ -1227,11 +1347,17 @@ void remainderRR(Context* c, unsigned aSize, lir::Register* a,
   moveRR(c, vm::TargetBytesPerWord, &dx, vm::TargetBytesPerWord, b);
 }
 
-void doShift(Context* c, UNUSED void (*shift)
-        (Context*, unsigned, lir::Register*, unsigned,
-         lir::Register*),
-        int type, UNUSED unsigned aSize, lir::Constant* a,
-        unsigned bSize, lir::Register* b)
+void doShift(Context* c,
+             UNUSED void (*shift)(Context*,
+                                  unsigned,
+                                  lir::Register*,
+                                  unsigned,
+                                  lir::Register*),
+             int type,
+             UNUSED unsigned aSize,
+             lir::Constant* a,
+             unsigned bSize,
+             lir::Register* b)
 {
   int64_t v = a->value->value();
 
@@ -1256,8 +1382,11 @@ void doShift(Context* c, UNUSED void (*shift)
   }
 }
 
-void shiftLeftRR(Context* c, UNUSED unsigned aSize, lir::Register* a,
-            unsigned bSize, lir::Register* b)
+void shiftLeftRR(Context* c,
+                 UNUSED unsigned aSize,
+                 lir::Register* a,
+                 unsigned bSize,
+                 lir::Register* b)
 {
   if (vm::TargetBytesPerWord == 4 and bSize == 8) {
     lir::Register cx(rcx);
@@ -1278,15 +1407,15 @@ void shiftLeftRR(Context* c, UNUSED unsigned aSize, lir::Register* a,
 
     ResolvedPromise promise(32);
     lir::Constant constant(&promise);
-    compareCR(c, vm::TargetBytesPerWord, &constant, vm::TargetBytesPerWord,
-              &cx);
+    compareCR(
+        c, vm::TargetBytesPerWord, &constant, vm::TargetBytesPerWord, &cx);
 
-    opcode(c, 0x7c); //jl
+    opcode(c, 0x7c);  // jl
     c->code.append(2 + 2);
 
     lir::Register bh(b->high);
-    moveRR(c, 4, b, 4, &bh); // 2 bytes
-    xorRR(c, 4, b, 4, b); // 2 bytes
+    moveRR(c, 4, b, 4, &bh);  // 2 bytes
+    xorRR(c, 4, b, 4, b);     // 2 bytes
   } else {
     assertT(c, a->low == rcx);
 
@@ -1295,14 +1424,20 @@ void shiftLeftRR(Context* c, UNUSED unsigned aSize, lir::Register* a,
   }
 }
 
-void shiftLeftCR(Context* c, unsigned aSize, lir::Constant* a,
-            unsigned bSize, lir::Register* b)
+void shiftLeftCR(Context* c,
+                 unsigned aSize,
+                 lir::Constant* a,
+                 unsigned bSize,
+                 lir::Register* b)
 {
   doShift(c, shiftLeftRR, 0xe0, aSize, a, bSize, b);
 }
 
-void shiftRightRR(Context* c, UNUSED unsigned aSize, lir::Register* a,
-             unsigned bSize, lir::Register* b)
+void shiftRightRR(Context* c,
+                  UNUSED unsigned aSize,
+                  lir::Register* a,
+                  unsigned bSize,
+                  lir::Register* b)
 {
   if (vm::TargetBytesPerWord == 4 and bSize == 8) {
     lir::Register cx(rcx);
@@ -1323,14 +1458,14 @@ void shiftRightRR(Context* c, UNUSED unsigned aSize, lir::Register* a,
 
     ResolvedPromise promise(32);
     lir::Constant constant(&promise);
-    compareCR(c, vm::TargetBytesPerWord, &constant, vm::TargetBytesPerWord,
-              &cx);
+    compareCR(
+        c, vm::TargetBytesPerWord, &constant, vm::TargetBytesPerWord, &cx);
 
-    opcode(c, 0x7c); //jl
+    opcode(c, 0x7c);  // jl
     c->code.append(2 + 3);
 
     lir::Register bh(b->high);
-    moveRR(c, 4, &bh, 4, b); // 2 bytes
+    moveRR(c, 4, &bh, 4, b);  // 2 bytes
 
     // sar 31,high
     opcode(c, 0xc1, 0xf8 + b->high);
@@ -1343,14 +1478,20 @@ void shiftRightRR(Context* c, UNUSED unsigned aSize, lir::Register* a,
   }
 }
 
-void shiftRightCR(Context* c, unsigned aSize, lir::Constant* a,
-             unsigned bSize, lir::Register* b)
+void shiftRightCR(Context* c,
+                  unsigned aSize,
+                  lir::Constant* a,
+                  unsigned bSize,
+                  lir::Register* b)
 {
   doShift(c, shiftRightRR, 0xf8, aSize, a, bSize, b);
 }
 
-void unsignedShiftRightRR(Context* c, UNUSED unsigned aSize, lir::Register* a,
-                     unsigned bSize, lir::Register* b)
+void unsignedShiftRightRR(Context* c,
+                          UNUSED unsigned aSize,
+                          lir::Register* a,
+                          unsigned bSize,
+                          lir::Register* b)
 {
   if (vm::TargetBytesPerWord == 4 and bSize == 8) {
     lir::Register cx(rcx);
@@ -1371,15 +1512,15 @@ void unsignedShiftRightRR(Context* c, UNUSED unsigned aSize, lir::Register* a,
 
     ResolvedPromise promise(32);
     lir::Constant constant(&promise);
-    compareCR(c, vm::TargetBytesPerWord, &constant, vm::TargetBytesPerWord,
-              &cx);
+    compareCR(
+        c, vm::TargetBytesPerWord, &constant, vm::TargetBytesPerWord, &cx);
 
-    opcode(c, 0x7c); //jl
+    opcode(c, 0x7c);  // jl
     c->code.append(2 + 2);
 
     lir::Register bh(b->high);
-    moveRR(c, 4, &bh, 4, b); // 2 bytes
-    xorRR(c, 4, &bh, 4, &bh); // 2 bytes
+    moveRR(c, 4, &bh, 4, b);   // 2 bytes
+    xorRR(c, 4, &bh, 4, &bh);  // 2 bytes
   } else {
     assertT(c, a->low == rcx);
 
@@ -1388,111 +1529,165 @@ void unsignedShiftRightRR(Context* c, UNUSED unsigned aSize, lir::Register* a,
   }
 }
 
-void unsignedShiftRightCR(Context* c, unsigned aSize UNUSED, lir::Constant* a,
-                     unsigned bSize, lir::Register* b)
+void unsignedShiftRightCR(Context* c,
+                          unsigned aSize UNUSED,
+                          lir::Constant* a,
+                          unsigned bSize,
+                          lir::Register* b)
 {
   doShift(c, unsignedShiftRightRR, 0xe8, aSize, a, bSize, b);
 }
 
-void floatSqrtRR(Context* c, unsigned aSize, lir::Register* a,
-            unsigned bSize UNUSED, lir::Register* b)
+void floatSqrtRR(Context* c,
+                 unsigned aSize,
+                 lir::Register* a,
+                 unsigned bSize UNUSED,
+                 lir::Register* b)
 {
   floatRegOp(c, aSize, a, 4, b, 0x51);
 }
 
-void floatSqrtMR(Context* c, unsigned aSize, lir::Memory* a,
-            unsigned bSize UNUSED, lir::Register* b)
+void floatSqrtMR(Context* c,
+                 unsigned aSize,
+                 lir::Memory* a,
+                 unsigned bSize UNUSED,
+                 lir::Register* b)
 {
   floatMemOp(c, aSize, a, 4, b, 0x51);
 }
 
-void floatAddRR(Context* c, unsigned aSize, lir::Register* a,
-           unsigned bSize UNUSED, lir::Register* b)
+void floatAddRR(Context* c,
+                unsigned aSize,
+                lir::Register* a,
+                unsigned bSize UNUSED,
+                lir::Register* b)
 {
   floatRegOp(c, aSize, a, 4, b, 0x58);
 }
 
-void floatAddMR(Context* c, unsigned aSize, lir::Memory* a,
-           unsigned bSize UNUSED, lir::Register* b)
+void floatAddMR(Context* c,
+                unsigned aSize,
+                lir::Memory* a,
+                unsigned bSize UNUSED,
+                lir::Register* b)
 {
   floatMemOp(c, aSize, a, 4, b, 0x58);
 }
 
-void floatSubtractRR(Context* c, unsigned aSize, lir::Register* a,
-                unsigned bSize UNUSED, lir::Register* b)
+void floatSubtractRR(Context* c,
+                     unsigned aSize,
+                     lir::Register* a,
+                     unsigned bSize UNUSED,
+                     lir::Register* b)
 {
   floatRegOp(c, aSize, a, 4, b, 0x5c);
 }
 
-void floatSubtractMR(Context* c, unsigned aSize, lir::Memory* a,
-                unsigned bSize UNUSED, lir::Register* b)
+void floatSubtractMR(Context* c,
+                     unsigned aSize,
+                     lir::Memory* a,
+                     unsigned bSize UNUSED,
+                     lir::Register* b)
 {
   floatMemOp(c, aSize, a, 4, b, 0x5c);
 }
 
-void floatMultiplyRR(Context* c, unsigned aSize, lir::Register* a,
-                unsigned bSize UNUSED, lir::Register* b)
+void floatMultiplyRR(Context* c,
+                     unsigned aSize,
+                     lir::Register* a,
+                     unsigned bSize UNUSED,
+                     lir::Register* b)
 {
   floatRegOp(c, aSize, a, 4, b, 0x59);
 }
 
-void floatMultiplyMR(Context* c, unsigned aSize, lir::Memory* a,
-                unsigned bSize UNUSED, lir::Register* b)
+void floatMultiplyMR(Context* c,
+                     unsigned aSize,
+                     lir::Memory* a,
+                     unsigned bSize UNUSED,
+                     lir::Register* b)
 {
   floatMemOp(c, aSize, a, 4, b, 0x59);
 }
 
-void floatDivideRR(Context* c, unsigned aSize, lir::Register* a,
-              unsigned bSize UNUSED, lir::Register* b)
+void floatDivideRR(Context* c,
+                   unsigned aSize,
+                   lir::Register* a,
+                   unsigned bSize UNUSED,
+                   lir::Register* b)
 {
   floatRegOp(c, aSize, a, 4, b, 0x5e);
 }
 
-void floatDivideMR(Context* c, unsigned aSize, lir::Memory* a,
-              unsigned bSize UNUSED, lir::Register* b)
+void floatDivideMR(Context* c,
+                   unsigned aSize,
+                   lir::Memory* a,
+                   unsigned bSize UNUSED,
+                   lir::Register* b)
 {
   floatMemOp(c, aSize, a, 4, b, 0x5e);
 }
 
-void float2FloatRR(Context* c, unsigned aSize, lir::Register* a,
-              unsigned bSize UNUSED, lir::Register* b)
+void float2FloatRR(Context* c,
+                   unsigned aSize,
+                   lir::Register* a,
+                   unsigned bSize UNUSED,
+                   lir::Register* b)
 {
   floatRegOp(c, aSize, a, 4, b, 0x5a);
 }
 
-void float2FloatMR(Context* c, unsigned aSize, lir::Memory* a,
-              unsigned bSize UNUSED, lir::Register* b)
+void float2FloatMR(Context* c,
+                   unsigned aSize,
+                   lir::Memory* a,
+                   unsigned bSize UNUSED,
+                   lir::Register* b)
 {
   floatMemOp(c, aSize, a, 4, b, 0x5a);
 }
 
-void float2IntRR(Context* c, unsigned aSize, lir::Register* a,
-            unsigned bSize, lir::Register* b)
+void float2IntRR(Context* c,
+                 unsigned aSize,
+                 lir::Register* a,
+                 unsigned bSize,
+                 lir::Register* b)
 {
   assertT(c, not isFloatReg(b));
   floatRegOp(c, aSize, a, bSize, b, 0x2c);
 }
 
-void float2IntMR(Context* c, unsigned aSize, lir::Memory* a,
-            unsigned bSize, lir::Register* b)
+void float2IntMR(Context* c,
+                 unsigned aSize,
+                 lir::Memory* a,
+                 unsigned bSize,
+                 lir::Register* b)
 {
   floatMemOp(c, aSize, a, bSize, b, 0x2c);
 }
 
-void int2FloatRR(Context* c, unsigned aSize, lir::Register* a,
-            unsigned bSize, lir::Register* b)
+void int2FloatRR(Context* c,
+                 unsigned aSize,
+                 lir::Register* a,
+                 unsigned bSize,
+                 lir::Register* b)
 {
   floatRegOp(c, bSize, a, aSize, b, 0x2a);
 }
 
-void int2FloatMR(Context* c, unsigned aSize, lir::Memory* a,
-            unsigned bSize, lir::Register* b)
+void int2FloatMR(Context* c,
+                 unsigned aSize,
+                 lir::Memory* a,
+                 unsigned bSize,
+                 lir::Register* b)
 {
   floatMemOp(c, bSize, a, aSize, b, 0x2a);
 }
 
-void floatNegateRR(Context* c, unsigned aSize, lir::Register* a,
-              unsigned bSize UNUSED, lir::Register* b)
+void floatNegateRR(Context* c,
+                   unsigned aSize,
+                   lir::Register* a,
+                   unsigned bSize UNUSED,
+                   lir::Register* b)
 {
   assertT(c, isFloatReg(a) and isFloatReg(b));
   // unlike most of the other floating point code, this does NOT
@@ -1509,15 +1704,19 @@ void floatNegateRR(Context* c, unsigned aSize, lir::Register* a,
     c->client->releaseTemporary(tmp.low);
   } else {
     moveCR(c, 4, &con, 4, b);
-    if (aSize == 8) opcode(c, 0x66);
+    if (aSize == 8)
+      opcode(c, 0x66);
     maybeRex(c, 4, a, b);
     opcode(c, 0x0f, 0x57);
     modrm(c, 0xc0, a, b);
   }
 }
 
-void floatAbsoluteRR(Context* c, unsigned aSize UNUSED, lir::Register* a,
-           unsigned bSize UNUSED, lir::Register* b)
+void floatAbsoluteRR(Context* c,
+                     unsigned aSize UNUSED,
+                     lir::Register* a,
+                     unsigned bSize UNUSED,
+                     lir::Register* b)
 {
   assertT(c, isFloatReg(a) and isFloatReg(b));
   // unlike most of the other floating point code, this does NOT
@@ -1540,12 +1739,14 @@ void floatAbsoluteRR(Context* c, unsigned aSize UNUSED, lir::Register* a,
   }
 }
 
-void absoluteRR(Context* c, unsigned aSize, lir::Register* a,
-      unsigned bSize UNUSED, lir::Register* b UNUSED)
+void absoluteRR(Context* c,
+                unsigned aSize,
+                lir::Register* a,
+                unsigned bSize UNUSED,
+                lir::Register* b UNUSED)
 {
   assertT(c, aSize == bSize and a->low == rax and b->low == rax);
-  lir::Register d
-    (c->client->acquireTemporary(static_cast<uint64_t>(1) << rdx));
+  lir::Register d(c->client->acquireTemporary(static_cast<uint64_t>(1) << rdx));
   maybeRex(c, aSize, a, b);
   opcode(c, 0x99);
   xorRR(c, aSize, &d, aSize, a);
@@ -1553,6 +1754,6 @@ void absoluteRR(Context* c, unsigned aSize, lir::Register* a,
   c->client->releaseTemporary(rdx);
 }
 
-} // namespace x86
-} // namespace codegen
-} // namespace avian
+}  // namespace x86
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/target/x86/operations.h b/src/codegen/target/x86/operations.h
index 770c8cea7f..80f985f042 100644
--- a/src/codegen/target/x86/operations.h
+++ b/src/codegen/target/x86/operations.h
@@ -59,212 +59,401 @@ void popR(Context* c, unsigned size, lir::Register* a);
 
 void negateR(Context* c, unsigned size, lir::Register* a);
 
-void negateRR(Context* c, unsigned aSize, lir::Register* a,
-         unsigned bSize UNUSED, lir::Register* b UNUSED);
+void negateRR(Context* c,
+              unsigned aSize,
+              lir::Register* a,
+              unsigned bSize UNUSED,
+              lir::Register* b UNUSED);
 
-void moveCR(Context* c, unsigned aSize, lir::Constant* a,
-       unsigned bSize, lir::Register* b);
+void moveCR(Context* c,
+            unsigned aSize,
+            lir::Constant* a,
+            unsigned bSize,
+            lir::Register* b);
 
-void moveZCR(Context* c, unsigned aSize, lir::Constant* a,
-             unsigned bSize, lir::Register* b);
+void moveZCR(Context* c,
+             unsigned aSize,
+             lir::Constant* a,
+             unsigned bSize,
+             lir::Register* b);
 
-void swapRR(Context* c, unsigned aSize UNUSED, lir::Register* a,
-       unsigned bSize UNUSED, lir::Register* b);
+void swapRR(Context* c,
+            unsigned aSize UNUSED,
+            lir::Register* a,
+            unsigned bSize UNUSED,
+            lir::Register* b);
 
-void moveRR(Context* c, unsigned aSize, lir::Register* a,
-       UNUSED unsigned bSize, lir::Register* b);
+void moveRR(Context* c,
+            unsigned aSize,
+            lir::Register* a,
+            UNUSED unsigned bSize,
+            lir::Register* b);
 
-void moveMR(Context* c, unsigned aSize, lir::Memory* a,
-       unsigned bSize, lir::Register* b);
+void moveMR(Context* c,
+            unsigned aSize,
+            lir::Memory* a,
+            unsigned bSize,
+            lir::Register* b);
 
-void moveRM(Context* c, unsigned aSize, lir::Register* a,
-       unsigned bSize UNUSED, lir::Memory* b);
+void moveRM(Context* c,
+            unsigned aSize,
+            lir::Register* a,
+            unsigned bSize UNUSED,
+            lir::Memory* b);
 
-void moveAR(Context* c, unsigned aSize, lir::Address* a,
-       unsigned bSize, lir::Register* b);
+void moveAR(Context* c,
+            unsigned aSize,
+            lir::Address* a,
+            unsigned bSize,
+            lir::Register* b);
 
-void moveCM(Context* c, unsigned aSize UNUSED, lir::Constant* a,
-       unsigned bSize, lir::Memory* b);
+void moveCM(Context* c,
+            unsigned aSize UNUSED,
+            lir::Constant* a,
+            unsigned bSize,
+            lir::Memory* b);
 
-void moveZRR(Context* c, unsigned aSize, lir::Register* a,
-        unsigned bSize UNUSED, lir::Register* b);
+void moveZRR(Context* c,
+             unsigned aSize,
+             lir::Register* a,
+             unsigned bSize UNUSED,
+             lir::Register* b);
 
-void moveZMR(Context* c, unsigned aSize UNUSED, lir::Memory* a,
-        unsigned bSize UNUSED, lir::Register* b);
+void moveZMR(Context* c,
+             unsigned aSize UNUSED,
+             lir::Memory* a,
+             unsigned bSize UNUSED,
+             lir::Register* b);
 
-void addCarryRR(Context* c, unsigned size, lir::Register* a,
+void addCarryRR(Context* c, unsigned size, lir::Register* a, lir::Register* b);
+
+void addRR(Context* c,
+           unsigned aSize,
+           lir::Register* a,
+           unsigned bSize UNUSED,
            lir::Register* b);
 
-void addRR(Context* c, unsigned aSize, lir::Register* a,
-      unsigned bSize UNUSED, lir::Register* b);
+void addCarryCR(Context* c, unsigned size, lir::Constant* a, lir::Register* b);
 
-void addCarryCR(Context* c, unsigned size, lir::Constant* a,
+void addCR(Context* c,
+           unsigned aSize,
+           lir::Constant* a,
+           unsigned bSize,
            lir::Register* b);
 
-void addCR(Context* c, unsigned aSize, lir::Constant* a,
-      unsigned bSize, lir::Register* b);
+void subtractBorrowCR(Context* c,
+                      unsigned size UNUSED,
+                      lir::Constant* a,
+                      lir::Register* b);
 
-void subtractBorrowCR(Context* c, unsigned size UNUSED, lir::Constant* a,
+void subtractCR(Context* c,
+                unsigned aSize,
+                lir::Constant* a,
+                unsigned bSize,
+                lir::Register* b);
+
+void subtractBorrowRR(Context* c,
+                      unsigned size,
+                      lir::Register* a,
+                      lir::Register* b);
+
+void subtractRR(Context* c,
+                unsigned aSize,
+                lir::Register* a,
+                unsigned bSize UNUSED,
+                lir::Register* b);
+
+void andRR(Context* c,
+           unsigned aSize,
+           lir::Register* a,
+           unsigned bSize UNUSED,
+           lir::Register* b);
+
+void andCR(Context* c,
+           unsigned aSize,
+           lir::Constant* a,
+           unsigned bSize,
+           lir::Register* b);
+
+void orRR(Context* c,
+          unsigned aSize,
+          lir::Register* a,
+          unsigned bSize UNUSED,
+          lir::Register* b);
+
+void orCR(Context* c,
+          unsigned aSize,
+          lir::Constant* a,
+          unsigned bSize,
+          lir::Register* b);
+
+void xorRR(Context* c,
+           unsigned aSize,
+           lir::Register* a,
+           unsigned bSize UNUSED,
+           lir::Register* b);
+
+void xorCR(Context* c,
+           unsigned aSize,
+           lir::Constant* a,
+           unsigned bSize,
+           lir::Register* b);
+
+void multiplyRR(Context* c,
+                unsigned aSize,
+                lir::Register* a,
+                unsigned bSize UNUSED,
+                lir::Register* b);
+
+void compareRR(Context* c,
+               unsigned aSize,
+               lir::Register* a,
+               unsigned bSize UNUSED,
+               lir::Register* b);
+
+void compareCR(Context* c,
+               unsigned aSize,
+               lir::Constant* a,
+               unsigned bSize,
+               lir::Register* b);
+
+void compareRM(Context* c,
+               unsigned aSize,
+               lir::Register* a,
+               unsigned bSize UNUSED,
+               lir::Memory* b);
+
+void compareCM(Context* c,
+               unsigned aSize,
+               lir::Constant* a,
+               unsigned bSize,
+               lir::Memory* b);
+
+void compareFloatRR(Context* c,
+                    unsigned aSize,
+                    lir::Register* a,
+                    unsigned bSize UNUSED,
+                    lir::Register* b);
+
+void branchLong(Context* c,
+                lir::TernaryOperation op,
+                lir::Operand* al,
+                lir::Operand* ah,
+                lir::Operand* bl,
+                lir::Operand* bh,
+                lir::Constant* target,
+                BinaryOperationType compare);
+
+void branchRR(Context* c,
+              lir::TernaryOperation op,
+              unsigned size,
+              lir::Register* a,
+              lir::Register* b,
+              lir::Constant* target);
+
+void branchCR(Context* c,
+              lir::TernaryOperation op,
+              unsigned size,
+              lir::Constant* a,
+              lir::Register* b,
+              lir::Constant* target);
+
+void branchRM(Context* c,
+              lir::TernaryOperation op,
+              unsigned size,
+              lir::Register* a,
+              lir::Memory* b,
+              lir::Constant* target);
+
+void branchCM(Context* c,
+              lir::TernaryOperation op,
+              unsigned size,
+              lir::Constant* a,
+              lir::Memory* b,
+              lir::Constant* target);
+
+void multiplyCR(Context* c,
+                unsigned aSize,
+                lir::Constant* a,
+                unsigned bSize,
+                lir::Register* b);
+
+void divideRR(Context* c,
+              unsigned aSize,
+              lir::Register* a,
+              unsigned bSize UNUSED,
+              lir::Register* b UNUSED);
+
+void remainderRR(Context* c,
+                 unsigned aSize,
+                 lir::Register* a,
+                 unsigned bSize UNUSED,
                  lir::Register* b);
 
-void subtractCR(Context* c, unsigned aSize, lir::Constant* a,
-           unsigned bSize, lir::Register* b);
+void doShift(Context* c,
+             UNUSED void (*shift)(Context*,
+                                  unsigned,
+                                  lir::Register*,
+                                  unsigned,
+                                  lir::Register*),
+             int type,
+             UNUSED unsigned aSize,
+             lir::Constant* a,
+             unsigned bSize,
+             lir::Register* b);
 
-void subtractBorrowRR(Context* c, unsigned size, lir::Register* a,
+void shiftLeftRR(Context* c,
+                 UNUSED unsigned aSize,
+                 lir::Register* a,
+                 unsigned bSize,
                  lir::Register* b);
 
-void subtractRR(Context* c, unsigned aSize, lir::Register* a,
-           unsigned bSize UNUSED, lir::Register* b);
+void shiftLeftCR(Context* c,
+                 unsigned aSize,
+                 lir::Constant* a,
+                 unsigned bSize,
+                 lir::Register* b);
 
-void andRR(Context* c, unsigned aSize, lir::Register* a,
-      unsigned bSize UNUSED, lir::Register* b);
+void shiftRightRR(Context* c,
+                  UNUSED unsigned aSize,
+                  lir::Register* a,
+                  unsigned bSize,
+                  lir::Register* b);
 
-void andCR(Context* c, unsigned aSize, lir::Constant* a,
-      unsigned bSize, lir::Register* b);
+void shiftRightCR(Context* c,
+                  unsigned aSize,
+                  lir::Constant* a,
+                  unsigned bSize,
+                  lir::Register* b);
 
-void orRR(Context* c, unsigned aSize, lir::Register* a,
-     unsigned bSize UNUSED, lir::Register* b);
+void unsignedShiftRightRR(Context* c,
+                          UNUSED unsigned aSize,
+                          lir::Register* a,
+                          unsigned bSize,
+                          lir::Register* b);
 
-void orCR(Context* c, unsigned aSize, lir::Constant* a,
-     unsigned bSize, lir::Register* b);
+void unsignedShiftRightCR(Context* c,
+                          unsigned aSize UNUSED,
+                          lir::Constant* a,
+                          unsigned bSize,
+                          lir::Register* b);
 
-void xorRR(Context* c, unsigned aSize, lir::Register* a,
-      unsigned bSize UNUSED, lir::Register* b);
+void floatSqrtRR(Context* c,
+                 unsigned aSize,
+                 lir::Register* a,
+                 unsigned bSize UNUSED,
+                 lir::Register* b);
 
-void xorCR(Context* c, unsigned aSize, lir::Constant* a,
-      unsigned bSize, lir::Register* b);
+void floatSqrtMR(Context* c,
+                 unsigned aSize,
+                 lir::Memory* a,
+                 unsigned bSize UNUSED,
+                 lir::Register* b);
 
-void multiplyRR(Context* c, unsigned aSize, lir::Register* a,
-           unsigned bSize UNUSED, lir::Register* b);
+void floatAddRR(Context* c,
+                unsigned aSize,
+                lir::Register* a,
+                unsigned bSize UNUSED,
+                lir::Register* b);
 
-void compareRR(Context* c, unsigned aSize, lir::Register* a,
-          unsigned bSize UNUSED, lir::Register* b);
+void floatAddMR(Context* c,
+                unsigned aSize,
+                lir::Memory* a,
+                unsigned bSize UNUSED,
+                lir::Register* b);
 
-void compareCR(Context* c, unsigned aSize, lir::Constant* a,
-          unsigned bSize, lir::Register* b);
+void floatSubtractRR(Context* c,
+                     unsigned aSize,
+                     lir::Register* a,
+                     unsigned bSize UNUSED,
+                     lir::Register* b);
 
-void compareRM(Context* c, unsigned aSize, lir::Register* a,
-          unsigned bSize UNUSED, lir::Memory* b);
+void floatSubtractMR(Context* c,
+                     unsigned aSize,
+                     lir::Memory* a,
+                     unsigned bSize UNUSED,
+                     lir::Register* b);
 
-void compareCM(Context* c, unsigned aSize, lir::Constant* a,
-          unsigned bSize, lir::Memory* b);
+void floatMultiplyRR(Context* c,
+                     unsigned aSize,
+                     lir::Register* a,
+                     unsigned bSize UNUSED,
+                     lir::Register* b);
 
-void compareFloatRR(Context* c, unsigned aSize, lir::Register* a,
-               unsigned bSize UNUSED, lir::Register* b);
+void floatMultiplyMR(Context* c,
+                     unsigned aSize,
+                     lir::Memory* a,
+                     unsigned bSize UNUSED,
+                     lir::Register* b);
 
-void branchLong(Context* c, lir::TernaryOperation op, lir::Operand* al,
-           lir::Operand* ah, lir::Operand* bl,
-           lir::Operand* bh, lir::Constant* target,
-           BinaryOperationType compare);
+void floatDivideRR(Context* c,
+                   unsigned aSize,
+                   lir::Register* a,
+                   unsigned bSize UNUSED,
+                   lir::Register* b);
 
-void branchRR(Context* c, lir::TernaryOperation op, unsigned size,
-         lir::Register* a, lir::Register* b,
-         lir::Constant* target);
+void floatDivideMR(Context* c,
+                   unsigned aSize,
+                   lir::Memory* a,
+                   unsigned bSize UNUSED,
+                   lir::Register* b);
 
-void branchCR(Context* c, lir::TernaryOperation op, unsigned size,
-         lir::Constant* a, lir::Register* b,
-         lir::Constant* target);
+void float2FloatRR(Context* c,
+                   unsigned aSize,
+                   lir::Register* a,
+                   unsigned bSize UNUSED,
+                   lir::Register* b);
 
-void branchRM(Context* c, lir::TernaryOperation op, unsigned size,
-         lir::Register* a, lir::Memory* b,
-         lir::Constant* target);
+void float2FloatMR(Context* c,
+                   unsigned aSize,
+                   lir::Memory* a,
+                   unsigned bSize UNUSED,
+                   lir::Register* b);
 
-void branchCM(Context* c, lir::TernaryOperation op, unsigned size,
-         lir::Constant* a, lir::Memory* b,
-         lir::Constant* target);
+void float2IntRR(Context* c,
+                 unsigned aSize,
+                 lir::Register* a,
+                 unsigned bSize,
+                 lir::Register* b);
 
-void multiplyCR(Context* c, unsigned aSize, lir::Constant* a,
-           unsigned bSize, lir::Register* b);
+void float2IntMR(Context* c,
+                 unsigned aSize,
+                 lir::Memory* a,
+                 unsigned bSize,
+                 lir::Register* b);
 
-void divideRR(Context* c, unsigned aSize, lir::Register* a,
-         unsigned bSize UNUSED, lir::Register* b UNUSED);
+void int2FloatRR(Context* c,
+                 unsigned aSize,
+                 lir::Register* a,
+                 unsigned bSize,
+                 lir::Register* b);
 
-void remainderRR(Context* c, unsigned aSize, lir::Register* a,
-            unsigned bSize UNUSED, lir::Register* b);
+void int2FloatMR(Context* c,
+                 unsigned aSize,
+                 lir::Memory* a,
+                 unsigned bSize,
+                 lir::Register* b);
 
-void doShift(Context* c, UNUSED void (*shift)
-        (Context*, unsigned, lir::Register*, unsigned,
-         lir::Register*),
-        int type, UNUSED unsigned aSize, lir::Constant* a,
-        unsigned bSize, lir::Register* b);
+void floatNegateRR(Context* c,
+                   unsigned aSize,
+                   lir::Register* a,
+                   unsigned bSize UNUSED,
+                   lir::Register* b);
 
-void shiftLeftRR(Context* c, UNUSED unsigned aSize, lir::Register* a,
-            unsigned bSize, lir::Register* b);
+void floatAbsoluteRR(Context* c,
+                     unsigned aSize UNUSED,
+                     lir::Register* a,
+                     unsigned bSize UNUSED,
+                     lir::Register* b);
 
-void shiftLeftCR(Context* c, unsigned aSize, lir::Constant* a,
-            unsigned bSize, lir::Register* b);
+void absoluteRR(Context* c,
+                unsigned aSize,
+                lir::Register* a,
+                unsigned bSize UNUSED,
+                lir::Register* b UNUSED);
 
-void shiftRightRR(Context* c, UNUSED unsigned aSize, lir::Register* a,
-             unsigned bSize, lir::Register* b);
+}  // namespace x86
+}  // namespace codegen
+}  // namespace avian
 
-void shiftRightCR(Context* c, unsigned aSize, lir::Constant* a,
-             unsigned bSize, lir::Register* b);
-
-void unsignedShiftRightRR(Context* c, UNUSED unsigned aSize, lir::Register* a,
-                     unsigned bSize, lir::Register* b);
-
-void unsignedShiftRightCR(Context* c, unsigned aSize UNUSED, lir::Constant* a,
-                     unsigned bSize, lir::Register* b);
-
-void floatSqrtRR(Context* c, unsigned aSize, lir::Register* a,
-            unsigned bSize UNUSED, lir::Register* b);
-
-void floatSqrtMR(Context* c, unsigned aSize, lir::Memory* a,
-            unsigned bSize UNUSED, lir::Register* b);
-
-void floatAddRR(Context* c, unsigned aSize, lir::Register* a,
-           unsigned bSize UNUSED, lir::Register* b);
-
-void floatAddMR(Context* c, unsigned aSize, lir::Memory* a,
-           unsigned bSize UNUSED, lir::Register* b);
-
-void floatSubtractRR(Context* c, unsigned aSize, lir::Register* a,
-                unsigned bSize UNUSED, lir::Register* b);
-
-void floatSubtractMR(Context* c, unsigned aSize, lir::Memory* a,
-                unsigned bSize UNUSED, lir::Register* b);
-
-void floatMultiplyRR(Context* c, unsigned aSize, lir::Register* a,
-                unsigned bSize UNUSED, lir::Register* b);
-
-void floatMultiplyMR(Context* c, unsigned aSize, lir::Memory* a,
-                unsigned bSize UNUSED, lir::Register* b);
-
-void floatDivideRR(Context* c, unsigned aSize, lir::Register* a,
-              unsigned bSize UNUSED, lir::Register* b);
-
-void floatDivideMR(Context* c, unsigned aSize, lir::Memory* a,
-              unsigned bSize UNUSED, lir::Register* b);
-
-void float2FloatRR(Context* c, unsigned aSize, lir::Register* a,
-              unsigned bSize UNUSED, lir::Register* b);
-
-void float2FloatMR(Context* c, unsigned aSize, lir::Memory* a,
-              unsigned bSize UNUSED, lir::Register* b);
-
-void float2IntRR(Context* c, unsigned aSize, lir::Register* a,
-            unsigned bSize, lir::Register* b);
-
-void float2IntMR(Context* c, unsigned aSize, lir::Memory* a,
-            unsigned bSize, lir::Register* b);
-
-void int2FloatRR(Context* c, unsigned aSize, lir::Register* a,
-            unsigned bSize, lir::Register* b);
-
-void int2FloatMR(Context* c, unsigned aSize, lir::Memory* a,
-            unsigned bSize, lir::Register* b);
-
-void floatNegateRR(Context* c, unsigned aSize, lir::Register* a,
-              unsigned bSize UNUSED, lir::Register* b);
-
-void floatAbsoluteRR(Context* c, unsigned aSize UNUSED, lir::Register* a,
-           unsigned bSize UNUSED, lir::Register* b);
-
-void absoluteRR(Context* c, unsigned aSize, lir::Register* a,
-      unsigned bSize UNUSED, lir::Register* b UNUSED);
-
-} // namespace x86
-} // namespace codegen
-} // namespace avian
-
-#endif // AVIAN_CODEGEN_ASSEMBLER_X86_OPERATIONS_H
+#endif  // AVIAN_CODEGEN_ASSEMBLER_X86_OPERATIONS_H
diff --git a/src/codegen/target/x86/padding.cpp b/src/codegen/target/x86/padding.cpp
index 330a1debc1..dcd0c83df4 100644
--- a/src/codegen/target/x86/padding.cpp
+++ b/src/codegen/target/x86/padding.cpp
@@ -18,12 +18,14 @@ namespace avian {
 namespace codegen {
 namespace x86 {
 
-AlignmentPadding::AlignmentPadding(Context* c, unsigned instructionOffset, unsigned alignment):
-  offset(c->code.length()),
-  instructionOffset(instructionOffset),
-  alignment(alignment),
-  next(0),
-  padding(-1)
+AlignmentPadding::AlignmentPadding(Context* c,
+                                   unsigned instructionOffset,
+                                   unsigned alignment)
+    : offset(c->code.length()),
+      instructionOffset(instructionOffset),
+      alignment(alignment),
+      next(0),
+      padding(-1)
 {
   if (c->lastBlock->firstPadding) {
     c->lastBlock->lastPadding->next = this;
@@ -33,9 +35,10 @@ AlignmentPadding::AlignmentPadding(Context* c, unsigned instructionOffset, unsig
   c->lastBlock->lastPadding = this;
 }
 
-unsigned
-padding(AlignmentPadding* p, unsigned start, unsigned offset,
-        AlignmentPadding* limit)
+unsigned padding(AlignmentPadding* p,
+                 unsigned start,
+                 unsigned offset,
+                 AlignmentPadding* limit)
 {
   unsigned padding = 0;
   if (limit) {
@@ -44,14 +47,14 @@ padding(AlignmentPadding* p, unsigned start, unsigned offset,
         if (p->padding == -1) {
           unsigned index = p->offset - offset;
           while ((start + index + padding + p->instructionOffset)
-                 % p->alignment)
-          {
-            ++ padding;
+                 % p->alignment) {
+            ++padding;
           }
-      
+
           p->padding = padding;
 
-          if (p == limit) break;
+          if (p == limit)
+            break;
         } else {
           padding = p->padding;
         }
@@ -63,6 +66,6 @@ padding(AlignmentPadding* p, unsigned start, unsigned offset,
   return padding;
 }
 
-} // namespace x86
-} // namespace codegen
-} // namespace avian
+}  // namespace x86
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/codegen/target/x86/padding.h b/src/codegen/target/x86/padding.h
index f7bef3ccf8..625b3008e0 100644
--- a/src/codegen/target/x86/padding.h
+++ b/src/codegen/target/x86/padding.h
@@ -28,12 +28,13 @@ class AlignmentPadding {
   int padding;
 };
 
-unsigned
-padding(AlignmentPadding* p, unsigned start, unsigned offset,
-        AlignmentPadding* limit);
+unsigned padding(AlignmentPadding* p,
+                 unsigned start,
+                 unsigned offset,
+                 AlignmentPadding* limit);
 
-} // namespace x86
-} // namespace codegen
-} // namespace avian
+}  // namespace x86
+}  // namespace codegen
+}  // namespace avian
 
-#endif // AVIAN_CODEGEN_ASSEMBLER_X86_PADDING_H
+#endif  // AVIAN_CODEGEN_ASSEMBLER_X86_PADDING_H
diff --git a/src/codegen/target/x86/registers.h b/src/codegen/target/x86/registers.h
index 54af5a18ec..b61e521b7c 100644
--- a/src/codegen/target/x86/registers.h
+++ b/src/codegen/target/x86/registers.h
@@ -55,13 +55,14 @@ enum {
 
 const int LongJumpRegister = r10;
 
-const unsigned GeneralRegisterMask = vm::TargetBytesPerWord == 4 ? 0x000000ff : 0x0000ffff;
+const unsigned GeneralRegisterMask = vm::TargetBytesPerWord == 4 ? 0x000000ff
+                                                                 : 0x0000ffff;
 
-const unsigned FloatRegisterMask = vm::TargetBytesPerWord == 4 ? 0x00ff0000 : 0xffff0000;
+const unsigned FloatRegisterMask = vm::TargetBytesPerWord == 4 ? 0x00ff0000
+                                                               : 0xffff0000;
 
+}  // namespace x86
+}  // namespace codegen
+}  // namespace avian
 
-} // namespace x86
-} // namespace codegen
-} // namespace avian
-
-#endif // AVIAN_CODEGEN_ASSEMBLER_X86_REGISTERS_H
+#endif  // AVIAN_CODEGEN_ASSEMBLER_X86_REGISTERS_H
diff --git a/src/codegen/targets.cpp b/src/codegen/targets.cpp
index b4aaa99a51..e981e8a497 100644
--- a/src/codegen/targets.cpp
+++ b/src/codegen/targets.cpp
@@ -17,22 +17,25 @@
 namespace avian {
 namespace codegen {
 
-Architecture* makeArchitectureNative(vm::System* system, bool useNativeFeatures UNUSED) {
+Architecture* makeArchitectureNative(vm::System* system,
+                                     bool useNativeFeatures UNUSED)
+{
 #ifndef AVIAN_TARGET_ARCH
-  #error "Must specify native target!"
+#error "Must specify native target!"
 #endif
 
 #if AVIAN_TARGET_ARCH == AVIAN_ARCH_UNKNOWN
   system->abort();
   return 0;
-#elif (AVIAN_TARGET_ARCH == AVIAN_ARCH_X86) || (AVIAN_TARGET_ARCH == AVIAN_ARCH_X86_64)
+#elif(AVIAN_TARGET_ARCH == AVIAN_ARCH_X86) \
+    || (AVIAN_TARGET_ARCH == AVIAN_ARCH_X86_64)
   return makeArchitectureX86(system, useNativeFeatures);
 #elif AVIAN_TARGET_ARCH == AVIAN_ARCH_ARM
   return makeArchitectureArm(system, useNativeFeatures);
 #else
-  #error "Unsupported codegen target"
+#error "Unsupported codegen target"
 #endif
 }
 
-} // namespace codegen
-} // namespace avian
+}  // namespace codegen
+}  // namespace avian
diff --git a/src/compile.cpp b/src/compile.cpp
index 7b4b159fc7..d1b66c704e 100644
--- a/src/compile.cpp
+++ b/src/compile.cpp
@@ -31,20 +31,23 @@
 
 using namespace vm;
 
-extern "C" uint64_t
-vmInvoke(void* thread, void* function, void* arguments,
-         unsigned argumentFootprint, unsigned frameSize, unsigned returnType);
+extern "C" uint64_t vmInvoke(void* thread,
+                             void* function,
+                             void* arguments,
+                             unsigned argumentFootprint,
+                             unsigned frameSize,
+                             unsigned returnType);
 
-extern "C" void
-vmInvoke_returnAddress();
+extern "C" void vmInvoke_returnAddress();
 
-extern "C" void
-vmInvoke_safeStack();
+extern "C" void vmInvoke_safeStack();
 
-extern "C" void
-vmJumpAndInvoke(void* thread, void* function, void* stack,
-                unsigned argumentFootprint, uintptr_t* arguments,
-                unsigned frameSize);
+extern "C" void vmJumpAndInvoke(void* thread,
+                                void* function,
+                                void* stack,
+                                unsigned argumentFootprint,
+                                uintptr_t* arguments,
+                                unsigned frameSize);
 
 using namespace avian::codegen;
 using namespace avian::system;
@@ -84,25 +87,22 @@ enum ThunkIndex {
 #define THUNK(s) s##Index,
 #include "thunks.cpp"
 #undef THUNK
-
   dummyIndex
 };
 
-inline bool
-isVmInvokeUnsafeStack(void* ip)
+inline bool isVmInvokeUnsafeStack(void* ip)
 {
   return reinterpret_cast<uintptr_t>(ip)
-    >= reinterpret_cast<uintptr_t>(voidPointer(vmInvoke_returnAddress))
-    and reinterpret_cast<uintptr_t>(ip)
-    < reinterpret_cast<uintptr_t> (voidPointer(vmInvoke_safeStack));
+         >= reinterpret_cast<uintptr_t>(voidPointer(vmInvoke_returnAddress))
+         and reinterpret_cast<uintptr_t>(ip)
+             < reinterpret_cast<uintptr_t>(voidPointer(vmInvoke_safeStack));
 }
 
 class MyThread;
 
-void*
-getIp(MyThread*);
+void* getIp(MyThread*);
 
-class MyThread: public Thread {
+class MyThread : public Thread {
  public:
   class CallTrace {
    public:
@@ -120,7 +120,8 @@ class MyThread: public Thread {
       doTransition(t, 0, 0, 0, this);
     }
 
-    ~CallTrace() {
+    ~CallTrace()
+    {
       assertT(t, t->stack == 0);
 
       t->scratch = scratch;
@@ -141,13 +142,15 @@ class MyThread: public Thread {
 
   class Context {
    public:
-    class MyProtector: public Thread::Protector {
+    class MyProtector : public Thread::Protector {
      public:
-      MyProtector(MyThread* t, Context* context):
-        Protector(t), context(context)
-      { }
+      MyProtector(MyThread* t, Context* context)
+          : Protector(t), context(context)
+      {
+      }
 
-      virtual void visit(Heap::Visitor* v) {
+      virtual void visit(Heap::Visitor* v)
+      {
         v->visit(&(context->continuation));
       }
 
@@ -164,7 +167,8 @@ class MyThread: public Thread {
           continuation(continuation),
           trace(trace),
           protector(t, this)
-    { }
+    {
+    }
 
     void* ip;
     void* stack;
@@ -173,7 +177,7 @@ class MyThread: public Thread {
     MyProtector protector;
   };
 
-  class TraceContext: public Context {
+  class TraceContext : public Context {
    public:
     TraceContext(MyThread* t,
                  void* ip,
@@ -189,17 +193,18 @@ class MyThread: public Thread {
       t->traceContext = this;
     }
 
-    TraceContext(MyThread* t, void* link):
-      Context(t, t->ip, t->stack, t->continuation, t->trace),
-      t(t),
-      link(link),
-      next(t->traceContext),
-      methodIsMostRecent(false)
+    TraceContext(MyThread* t, void* link)
+        : Context(t, t->ip, t->stack, t->continuation, t->trace),
+          t(t),
+          link(link),
+          next(t->traceContext),
+          methodIsMostRecent(false)
     {
       t->traceContext = this;
     }
 
-    ~TraceContext() {
+    ~TraceContext()
+    {
       t->traceContext = next;
     }
 
@@ -306,11 +311,10 @@ void transition(MyThread* t,
   MyThread::doTransition(t, ip, stack, continuation, trace);
 }
 
-object
-resolveThisPointer(MyThread* t, void* stack)
+object resolveThisPointer(MyThread* t, void* stack)
 {
-  return reinterpret_cast<object*>(stack)
-    [t->arch->frameFooterSize() + t->arch->frameReturnAddressSize()];
+  return reinterpret_cast<object*>(
+      stack)[t->arch->frameFooterSize() + t->arch->frameReturnAddressSize()];
 }
 
 GcMethod* findMethod(Thread* t, GcMethod* method, object instance)
@@ -373,7 +377,8 @@ intptr_t compareIpToMethodBounds(Thread* t, intptr_t ip, object om)
   intptr_t start = methodCompiled(t, method);
 
   if (DebugMethodTree) {
-    fprintf(stderr, "find %p in (%p,%p)\n",
+    fprintf(stderr,
+            "find %p in (%p,%p)\n",
             reinterpret_cast<void*>(ip),
             reinterpret_cast<void*>(start),
             reinterpret_cast<void*>(start + methodCompiledSize(t, method)));
@@ -381,9 +386,8 @@ intptr_t compareIpToMethodBounds(Thread* t, intptr_t ip, object om)
 
   if (ip < start) {
     return -1;
-  } else if (ip < start + static_cast<intptr_t>
-             (methodCompiledSize(t, method)))
-  {
+  } else if (ip < start
+                  + static_cast<intptr_t>(methodCompiledSize(t, method))) {
     return 0;
   } else {
     return 1;
@@ -413,7 +417,7 @@ unsigned localSize(MyThread* t UNUSED, GcMethod* method)
 {
   unsigned size = method->code()->maxLocals();
   if ((method->flags() & (ACC_SYNCHRONIZED | ACC_STATIC)) == ACC_SYNCHRONIZED) {
-    ++ size;
+    ++size;
   }
   return size;
 }
@@ -473,8 +477,7 @@ void nextFrame(MyThread* t,
   // fprintf(stderr, "next frame ip %p sp %p\n", *ip, *sp);
 }
 
-void*
-getIp(MyThread* t, void* ip, void* stack)
+void* getIp(MyThread* t, void* ip, void* stack)
 {
   // Here we use the convention that, if the return address is neither
   // pushed on to the stack automatically as part of the call nor
@@ -484,31 +487,23 @@ getIp(MyThread* t, void* ip, void* stack)
   return t->arch->returnAddressOffset() < 0 ? ip : t->arch->frameIp(stack);
 }
 
-void*
-getIp(MyThread* t)
+void* getIp(MyThread* t)
 {
   return getIp(t, t->ip, t->stack);
 }
 
-class MyStackWalker: public Processor::StackWalker {
+class MyStackWalker : public Processor::StackWalker {
  public:
-  enum State {
-    Start,
-    Next,
-    Trace,
-    Continuation,
-    Method,
-    NativeMethod,
-    Finish
-  };
+  enum State { Start, Next, Trace, Continuation, Method, NativeMethod, Finish };
 
-  class MyProtector: public Thread::Protector {
+  class MyProtector : public Thread::Protector {
    public:
-    MyProtector(MyStackWalker* walker):
-      Protector(walker->t), walker(walker)
-    { }
+    MyProtector(MyStackWalker* walker) : Protector(walker->t), walker(walker)
+    {
+    }
 
-    virtual void visit(Heap::Visitor* v) {
+    virtual void visit(Heap::Visitor* v)
+    {
       v->visit(&(walker->method_));
       v->visit(&(walker->target));
       v->visit(&(walker->continuation));
@@ -517,13 +512,8 @@ class MyStackWalker: public Processor::StackWalker {
     MyStackWalker* walker;
   };
 
-  MyStackWalker(MyThread* t):
-    t(t),
-    state(Start),
-    method_(0),
-    target(0),
-    count_(0),
-    protector(this)
+  MyStackWalker(MyThread* t)
+      : t(t), state(Start), method_(0), target(0), count_(0), protector(this)
   {
     if (t->traceContext) {
       ip_ = t->traceContext->ip;
@@ -538,20 +528,22 @@ class MyStackWalker: public Processor::StackWalker {
     }
   }
 
-  MyStackWalker(MyStackWalker* w):
-    t(w->t),
-    state(w->state),
-    ip_(w->ip_),
-    stack(w->stack),
-    trace(w->trace),
-    method_(w->method_),
-    target(w->target),
-    continuation(w->continuation),
-    count_(w->count_),
-    protector(this)
-  { }
+  MyStackWalker(MyStackWalker* w)
+      : t(w->t),
+        state(w->state),
+        ip_(w->ip_),
+        stack(w->stack),
+        trace(w->trace),
+        method_(w->method_),
+        target(w->target),
+        continuation(w->continuation),
+        count_(w->count_),
+        protector(this)
+  {
+  }
 
-  virtual void walk(Processor::StackVisitor* v) {
+  virtual void walk(Processor::StackVisitor* v)
+  {
     for (MyStackWalker it(this); it.valid();) {
       MyStackWalker walker(&it);
       if (not v->visit(&walker)) {
@@ -561,9 +553,10 @@ class MyStackWalker: public Processor::StackWalker {
     }
   }
 
-  bool valid() {
+  bool valid()
+  {
     while (true) {
-//       fprintf(stderr, "state: %d\n", state);
+      //       fprintf(stderr, "state: %d\n", state);
       switch (state) {
       case Start:
         if (trace and trace->nativeMethod) {
@@ -618,7 +611,8 @@ class MyStackWalker: public Processor::StackWalker {
     }
   }
 
-  void next() {
+  void next()
+  {
     expect(t, count_ <= stackSizeInWords(t));
 
     switch (state) {
@@ -637,20 +631,21 @@ class MyStackWalker: public Processor::StackWalker {
       abort(t);
     }
 
-    ++ count_;
+    ++count_;
 
     state = Next;
   }
 
   virtual GcMethod* method()
   {
-//     fprintf(stderr, "method %s.%s\n", &byteArrayBody
-//             (t, className(t, methodClass(t, method_)), 0),
-//             &byteArrayBody(t, methodName(t, method_), 0));
+    //     fprintf(stderr, "method %s.%s\n", &byteArrayBody
+    //             (t, className(t, methodClass(t, method_)), 0),
+    //             &byteArrayBody(t, methodName(t, method_), 0));
     return method_;
   }
 
-  virtual int ip() {
+  virtual int ip()
+  {
     switch (state) {
     case Continuation:
       return reinterpret_cast<intptr_t>(continuation->address())
@@ -667,12 +662,13 @@ class MyStackWalker: public Processor::StackWalker {
     }
   }
 
-  virtual unsigned count() {
+  virtual unsigned count()
+  {
     unsigned count = 0;
 
     for (MyStackWalker walker(this); walker.valid();) {
       walker.next();
-      ++ count;
+      ++count;
     }
 
     return count;
@@ -695,15 +691,11 @@ int localOffset(MyThread* t, int v, GcMethod* method)
   int parameterFootprint = method->parameterFootprint();
   int frameSize = alignedFrameSize(t, method);
 
-  int offset = ((v < parameterFootprint) ?
-                (frameSize
-                 + parameterFootprint
-                 + t->arch->frameFooterSize()
-                 + t->arch->frameHeaderSize()
-                 - v - 1) :
-                (frameSize
-                 + parameterFootprint
-                 - v - 1));
+  int offset
+      = ((v < parameterFootprint)
+             ? (frameSize + parameterFootprint + t->arch->frameFooterSize()
+                + t->arch->frameHeaderSize() - v - 1)
+             : (frameSize + parameterFootprint - v - 1));
 
   assertT(t, offset >= 0);
   return offset;
@@ -711,8 +703,7 @@ int localOffset(MyThread* t, int v, GcMethod* method)
 
 int localOffsetFromStack(MyThread* t, int index, GcMethod* method)
 {
-  return localOffset(t, index, method)
-    + t->arch->frameReturnAddressSize();
+  return localOffset(t, index, method) + t->arch->frameReturnAddressSize();
 }
 
 object* localObject(MyThread* t, void* stack, GcMethod* method, unsigned index)
@@ -730,18 +721,21 @@ void* stackForFrame(MyThread* t, void* frame, GcMethod* method)
   return static_cast<void**>(frame) - stackOffsetFromFrame(t, method);
 }
 
-class PoolElement: public avian::codegen::Promise {
+class PoolElement : public avian::codegen::Promise {
  public:
-  PoolElement(Thread* t, object target, PoolElement* next):
-    t(t), target(target), address(0), next(next)
-  { }
+  PoolElement(Thread* t, object target, PoolElement* next)
+      : t(t), target(target), address(0), next(next)
+  {
+  }
 
-  virtual int64_t value() {
+  virtual int64_t value()
+  {
     assertT(t, resolved());
     return address;
   }
 
-  virtual bool resolved() {
+  virtual bool resolved()
+  {
     return address != 0;
   }
 
@@ -762,7 +756,8 @@ class Subroutine {
         returnAddress(returnAddress),
         duplicatedBaseIp(methodSize * index),
         visited(false)
-  { }
+  {
+  }
 
   // Index of this subroutine, in the (unmaterialized) list of subroutines in
   // this method.
@@ -785,11 +780,11 @@ class Subroutine {
 
 class Context;
 
-class TraceElement: public avian::codegen::TraceHandler {
+class TraceElement : public avian::codegen::TraceHandler {
  public:
   static const unsigned VirtualCall = 1 << 0;
-  static const unsigned TailCall    = 1 << 1;
-  static const unsigned LongCall    = 1 << 2;
+  static const unsigned TailCall = 1 << 1;
+  static const unsigned LongCall = 1 << 2;
 
   TraceElement(Context* context,
                unsigned ip,
@@ -809,7 +804,9 @@ class TraceElement: public avian::codegen::TraceHandler {
     memset(map, 0xFF, mapSize * BytesPerWord);
   }
 
-  virtual void handleTrace(avian::codegen::Promise* address, unsigned argumentIndex) {
+  virtual void handleTrace(avian::codegen::Promise* address,
+                           unsigned argumentIndex)
+  {
     if (this->address == 0) {
       this->address = address;
       this->argumentIndex = argumentIndex;
@@ -827,16 +824,20 @@ class TraceElement: public avian::codegen::TraceHandler {
   uintptr_t map[0];
 };
 
-class TraceElementPromise: public avian::codegen::Promise {
+class TraceElementPromise : public avian::codegen::Promise {
  public:
-  TraceElementPromise(System* s, TraceElement* trace): s(s), trace(trace) { }
+  TraceElementPromise(System* s, TraceElement* trace) : s(s), trace(trace)
+  {
+  }
 
-  virtual int64_t value() {
+  virtual int64_t value()
+  {
     assertT(s, resolved());
     return trace->address->value();
   }
 
-  virtual bool resolved() {
+  virtual bool resolved()
+  {
     return trace->address != 0 and trace->address->resolved();
   }
 
@@ -874,16 +875,18 @@ enum Thunk {
 
 const unsigned ThunkCount = idleIfNecessaryThunk + 1;
 
-intptr_t
-getThunk(MyThread* t, Thunk thunk);
+intptr_t getThunk(MyThread* t, Thunk thunk);
 
 class BootContext {
  public:
-  class MyProtector: public Thread::Protector {
+  class MyProtector : public Thread::Protector {
    public:
-    MyProtector(Thread* t, BootContext* c): Protector(t), c(c) { }
+    MyProtector(Thread* t, BootContext* c) : Protector(t), c(c)
+    {
+    }
 
-    virtual void visit(Heap::Visitor* v) {
+    virtual void visit(Heap::Visitor* v)
+    {
       v->visit(&(c->constants));
       v->visit(&(c->calls));
     }
@@ -904,7 +907,8 @@ class BootContext {
         addressSentinal(addresses),
         zone(zone),
         resolver(resolver)
-  { }
+  {
+  }
 
   MyProtector protector;
   GcTriple* constants;
@@ -917,22 +921,28 @@ class BootContext {
 
 class Context {
  public:
-  class MyResource: public Thread::AutoResource {
+  class MyResource : public Thread::AutoResource {
    public:
-    MyResource(Context* c): AutoResource(c->thread), c(c) { }
+    MyResource(Context* c) : AutoResource(c->thread), c(c)
+    {
+    }
 
-    virtual void release() {
+    virtual void release()
+    {
       c->dispose();
     }
 
     Context* c;
   };
 
-  class MyProtector: public Thread::Protector {
+  class MyProtector : public Thread::Protector {
    public:
-    MyProtector(Context* c): Protector(c->thread), c(c) { }
+    MyProtector(Context* c) : Protector(c->thread), c(c)
+    {
+    }
 
-    virtual void visit(Heap::Visitor* v) {
+    virtual void visit(Heap::Visitor* v)
+    {
       v->visit(&(c->method));
 
       for (PoolElement* p = c->objectPool; p; p = p->next) {
@@ -947,19 +957,23 @@ class Context {
     Context* c;
   };
 
-  class MyClient: public Compiler::Client {
+  class MyClient : public Compiler::Client {
    public:
-    MyClient(MyThread* t): t(t) { }
+    MyClient(MyThread* t) : t(t)
+    {
+    }
 
-    virtual intptr_t getThunk(avian::codegen::lir::UnaryOperation, unsigned) {
+    virtual intptr_t getThunk(avian::codegen::lir::UnaryOperation, unsigned)
+    {
       abort(t);
     }
 
-    virtual intptr_t getThunk(avian::codegen::lir::BinaryOperation op, unsigned size,
+    virtual intptr_t getThunk(avian::codegen::lir::BinaryOperation op,
+                              unsigned size,
                               unsigned resultSize)
     {
       if (size == 8) {
-        switch(op) {
+        switch (op) {
         case avian::codegen::lir::Absolute:
           assertT(t, resultSize == 8);
           return local::getThunk(t, absoluteLongThunk);
@@ -992,12 +1006,13 @@ class Context {
             return local::getThunk(t, longToFloatThunk);
           }
 
-        default: abort(t);
+        default:
+          abort(t);
         }
       } else {
         assertT(t, size == 4);
 
-        switch(op) {
+        switch (op) {
         case avian::codegen::lir::Absolute:
           assertT(t, resultSize == 4);
           return local::getThunk(t, absoluteIntThunk);
@@ -1030,12 +1045,15 @@ class Context {
             return local::getThunk(t, intToDoubleThunk);
           }
 
-        default: abort(t);
+        default:
+          abort(t);
         }
       }
     }
 
-    virtual intptr_t getThunk(avian::codegen::lir::TernaryOperation op, unsigned size, unsigned,
+    virtual intptr_t getThunk(avian::codegen::lir::TernaryOperation op,
+                              unsigned size,
+                              unsigned,
                               bool* threadParameter)
     {
       *threadParameter = false;
@@ -1079,7 +1097,8 @@ class Context {
         case avian::codegen::lir::JumpIfFloatLessOrEqualOrUnordered:
           return local::getThunk(t, compareDoublesLThunk);
 
-        default: abort(t);
+        default:
+          abort(t);
         }
       } else {
         assertT(t, size == 4);
@@ -1121,7 +1140,8 @@ class Context {
         case avian::codegen::lir::JumpIfFloatLessOrEqualOrUnordered:
           return local::getThunk(t, compareFloatsLThunk);
 
-        default: abort(t);
+        default:
+          abort(t);
         }
       }
     }
@@ -1159,7 +1179,8 @@ class Context {
         argumentBuffer(
             (ir::Value**)t->m->heap->allocate(256 * sizeof(ir::Value*)),
             256)  // below the maximal allowed parameter count for Java
-  { }
+  {
+  }
 
   Context(MyThread* t)
       : thread(t),
@@ -1185,13 +1206,16 @@ class Context {
         protector(this),
         resource(this),
         argumentBuffer(0, 0)
-  { }
+  {
+  }
 
-  ~Context() {
+  ~Context()
+  {
     dispose();
   }
 
-  void dispose() {
+  void dispose()
+  {
     if (compiler) {
       compiler->dispose();
     }
@@ -1246,8 +1270,9 @@ class Context {
   Slice<ir::Value*> argumentBuffer;
 };
 
-unsigned
-translateLocalIndex(Context* context, unsigned footprint, unsigned index)
+unsigned translateLocalIndex(Context* context,
+                             unsigned footprint,
+                             unsigned index)
 {
   unsigned parameterFootprint = context->method->parameterFootprint();
 
@@ -1285,7 +1310,6 @@ avian::util::FixedAllocator* codeAllocator(MyThread* t);
 
 ir::Type operandTypeForFieldCode(Thread* t, unsigned code)
 {
-
   switch (code) {
   case ByteField:
   case BooleanField:
@@ -1372,11 +1396,13 @@ class Frame {
     }
   }
 
-  ~Frame() {
+  ~Frame()
+  {
     dispose();
   }
 
-  void dispose() {
+  void dispose()
+  {
     if (level > 1) {
       context->eventLog.append(PopContextEvent);
     }
@@ -1386,7 +1412,8 @@ class Frame {
   {
     BootContext* bc = context->bootContext;
     if (bc) {
-      avian::codegen::Promise* p = new (bc->zone) avian::codegen::ListenPromise(t->m->system, bc->zone);
+      avian::codegen::Promise* p = new (bc->zone)
+          avian::codegen::ListenPromise(t->m->system, bc->zone);
 
       PROTECT(t, o);
       object pointer = makePointer(t, p);
@@ -1405,23 +1432,27 @@ class Frame {
         }
       }
 
-      context->objectPool = new(&context->zone) PoolElement(t, o, context->objectPool);
+      context->objectPool = new (&context->zone)
+          PoolElement(t, o, context->objectPool);
 
-      ++ context->objectPoolCount;
+      ++context->objectPoolCount;
 
       return c->address(ir::Type::object(), context->objectPool);
     }
   }
 
-  unsigned localSize() {
+  unsigned localSize()
+  {
     return local::localSize(t, context->method);
   }
 
-  unsigned stackSize() {
+  unsigned stackSize()
+  {
     return context->method->code()->maxStack();
   }
 
-  unsigned frameSize() {
+  unsigned frameSize()
+  {
     return localSize() + stackSize();
   }
 
@@ -1451,19 +1482,22 @@ class Frame {
     return stackMap[si];
   }
 
-  void popped(unsigned count) {
+  void popped(unsigned count)
+  {
     assertT(t, sp >= count);
     assertT(t, sp - count >= localSize());
     while (count) {
       set(--sp, ir::Type::i4());
-      -- count;
+      --count;
     }
   }
 
-  avian::codegen::Promise* addressPromise(avian::codegen::Promise* p) {
+  avian::codegen::Promise* addressPromise(avian::codegen::Promise* p)
+  {
     BootContext* bc = context->bootContext;
     if (bc) {
-      bc->addresses = new(bc->zone) avian::codegen::DelayedPromise(t->m->system, bc->zone, p, bc->addresses);
+      bc->addresses = new (bc->zone) avian::codegen::DelayedPromise(
+          t->m->system, bc->zone, p, bc->addresses);
       return bc->addresses;
     } else {
       return p;
@@ -1540,7 +1574,8 @@ class Frame {
     set(sp++, type);
   }
 
-  void pushObject() {
+  void pushObject()
+  {
     c->pushed(ir::Type::object());
 
     assertT(t, sp + 1 <= frameSize());
@@ -1587,7 +1622,8 @@ class Frame {
     push(type, loadLocal(context, 1, type, index));
   }
 
-  void loadLarge(ir::Type type, unsigned index) {
+  void loadLarge(ir::Type type, unsigned index)
+  {
     assertT(t, index < static_cast<unsigned>(localSize() - 1));
     pushLarge(type, loadLocal(context, 2, type, index));
   }
@@ -1603,7 +1639,8 @@ class Frame {
     set(ti, type);
   }
 
-  void storeLarge(ir::Type type, unsigned index) {
+  void storeLarge(ir::Type type, unsigned index)
+  {
     storeLocal(context, 2, type, popLarge(type), index);
     unsigned ti = translateLocalIndex(context, 2, index);
     assertT(t, ti + 1 < localSize());
@@ -1611,16 +1648,18 @@ class Frame {
     set(ti + 1, type);
   }
 
-  void dup() {
+  void dup()
+  {
     c->push(ir::Type::i4(), c->peek(1, 0));
 
     assertT(t, sp + 1 <= frameSize());
     assertT(t, sp - 1 >= localSize());
     set(sp, get(sp - 1));
-    ++ sp;
+    ++sp;
   }
 
-  void dupX1() {
+  void dupX1()
+  {
     ir::Value* s0 = c->pop(ir::Type::i4());
     ir::Value* s1 = c->pop(ir::Type::i4());
 
@@ -1636,12 +1675,13 @@ class Frame {
 
     set(sp - 1, b2);
     set(sp - 2, b1);
-    set(sp    , b1);
+    set(sp, b1);
 
-    ++ sp;
+    ++sp;
   }
 
-  void dupX2() {
+  void dupX2()
+  {
     ir::Value* s0 = c->pop(ir::Type::i4());
 
     if (get(sp - 2) == ir::Type::i8()) {
@@ -1670,12 +1710,13 @@ class Frame {
     set(sp - 2, b3);
     set(sp - 1, b2);
     set(sp - 3, b1);
-    set(sp    , b1);
+    set(sp, b1);
 
-    ++ sp;
+    ++sp;
   }
 
-  void dup2() {
+  void dup2()
+  {
     if (get(sp - 1) == ir::Type::i8()) {
       c->push(ir::Type::i8(), c->peek(2, 0));
     } else {
@@ -1700,7 +1741,8 @@ class Frame {
     sp += 2;
   }
 
-  void dup2X1() {
+  void dup2X1()
+  {
     if (get(sp - 1) == ir::Type::i8()) {
       ir::Value* s0 = c->pop(ir::Type::i8());
       ir::Value* s1 = c->pop(ir::Type::i4());
@@ -1729,14 +1771,15 @@ class Frame {
 
     set(sp - 1, b3);
     set(sp - 3, b2);
-    set(sp    , b2);
+    set(sp, b2);
     set(sp - 2, b1);
     set(sp + 1, b1);
 
     sp += 2;
   }
 
-  void dup2X2() {
+  void dup2X2()
+  {
     if (get(sp - 1) == ir::Type::i8()) {
       ir::Value* s0 = c->pop(ir::Type::i8());
 
@@ -1780,14 +1823,15 @@ class Frame {
     set(sp - 2, b4);
     set(sp - 1, b3);
     set(sp - 4, b2);
-    set(sp    , b2);
+    set(sp, b2);
     set(sp - 3, b1);
     set(sp + 1, b1);
 
     sp += 2;
   }
 
-  void swap() {
+  void swap()
+  {
     ir::Value* s0 = c->pop(ir::Type::i4());
     ir::Value* s1 = c->pop(ir::Type::i4());
 
@@ -1815,7 +1859,7 @@ class Frame {
                      context->traceLog,
                      mapSize);
 
-    ++ context->traceLogCount;
+    ++context->traceLogCount;
 
     context->eventLog.append(TraceEvent);
     context->eventLog.appendAddress(e);
@@ -1969,8 +2013,7 @@ void* findExceptionHandler(Thread* t, GcMethod* method, void* ip)
     if (table) {
       GcIntArray* index = cast<GcIntArray>(t, table->body()[0]);
 
-      uint8_t* compiled = reinterpret_cast<uint8_t*>
-        (methodCompiled(t, method));
+      uint8_t* compiled = reinterpret_cast<uint8_t*>(methodCompiled(t, method));
 
       for (unsigned i = 0; i < table->length() - 1; ++i) {
         unsigned start = index->body()[i * 3];
@@ -1999,9 +2042,10 @@ void releaseLock(MyThread* t, GcMethod* method, void* stack)
       if (method->flags() & ACC_STATIC) {
         lock = method->class_();
       } else {
-        lock = *localObject
-          (t, stackForFrame(t, stack, method), method,
-           savedTargetIndex(t, method));
+        lock = *localObject(t,
+                            stackForFrame(t, stack, method),
+                            method,
+                            savedTargetIndex(t, method));
       }
 
       release(t, lock);
@@ -2049,10 +2093,10 @@ void findUnwindTarget(MyThread* t,
         nextFrame(t, &ip, &stack, method, target, mostRecent);
 
         void** sp = static_cast<void**>(stackForFrame(t, stack, method))
-          + t->arch->frameReturnAddressSize();
+                    + t->arch->frameReturnAddressSize();
 
-        *targetFrame = static_cast<void**>
-          (stack) + t->arch->framePointerOffset();
+        *targetFrame = static_cast<void**>(stack)
+                       + t->arch->framePointerOffset();
         *targetStack = sp;
         *targetContinuation = continuation;
 
@@ -2073,7 +2117,7 @@ void findUnwindTarget(MyThread* t,
       *targetIp = ip;
       *targetFrame = 0;
       *targetStack = static_cast<void**>(stack)
-        + t->arch->frameReturnAddressSize();
+                     + t->arch->frameReturnAddressSize();
       *targetContinuation = continuation;
 
       while (Continuations and *targetContinuation) {
@@ -2092,8 +2136,8 @@ void findUnwindTarget(MyThread* t,
                     - t->arch->framePointerOffset()
                     + t->arch->frameReturnAddressSize())) * BytesPerWord;
 
-          t->exceptionOffset
-            = localOffset(t, localSize(t, method), method) * BytesPerWord;
+          t->exceptionOffset = localOffset(t, localSize(t, method), method)
+                               * BytesPerWord;
 
           break;
         } else if (t->exception) {
@@ -2143,8 +2187,8 @@ GcContinuation* makeCurrentContinuation(MyThread* t,
       PROTECT(t, method);
 
       void** top = static_cast<void**>(stack)
-        + t->arch->frameReturnAddressSize()
-        + t->arch->frameFooterSize();
+                   + t->arch->frameReturnAddressSize()
+                   + t->arch->frameFooterSize();
       unsigned argumentFootprint
           = t->arch->argumentFootprint(target->parameterFootprint());
       unsigned alignment = t->arch->stackAlignmentInWords();
@@ -2156,7 +2200,7 @@ GcContinuation* makeCurrentContinuation(MyThread* t,
       nextFrame(t, &nextIp, &stack, method, target, mostRecent);
 
       void** bottom = static_cast<void**>(stack)
-          + t->arch->frameReturnAddressSize();
+                      + t->arch->frameReturnAddressSize();
       unsigned frameSize = bottom - top;
       unsigned totalSize
           = frameSize + t->arch->frameFooterSize()
@@ -2191,7 +2235,7 @@ GcContinuation* makeCurrentContinuation(MyThread* t,
     } else {
       *targetIp = ip;
       *targetStack = static_cast<void**>(stack)
-        + t->arch->frameReturnAddressSize();
+                     + t->arch->frameReturnAddressSize();
     }
 
     mostRecent = false;
@@ -2203,8 +2247,7 @@ GcContinuation* makeCurrentContinuation(MyThread* t,
   return first;
 }
 
-void NO_RETURN
-unwind(MyThread* t)
+void NO_RETURN unwind(MyThread* t)
 {
   void* ip;
   void* frame;
@@ -2220,35 +2263,31 @@ unwind(MyThread* t)
   vmJump(ip, frame, stack, t, 0, 0);
 }
 
-class MyCheckpoint: public Thread::Checkpoint {
+class MyCheckpoint : public Thread::Checkpoint {
  public:
-  MyCheckpoint(MyThread* t): Checkpoint(t) { }
+  MyCheckpoint(MyThread* t) : Checkpoint(t)
+  {
+  }
 
-  virtual void unwind() {
+  virtual void unwind()
+  {
     local::unwind(static_cast<MyThread*>(t));
   }
 };
 
-uintptr_t
-defaultThunk(MyThread* t);
+uintptr_t defaultThunk(MyThread* t);
 
-uintptr_t
-nativeThunk(MyThread* t);
+uintptr_t nativeThunk(MyThread* t);
 
-uintptr_t
-bootNativeThunk(MyThread* t);
+uintptr_t bootNativeThunk(MyThread* t);
 
-uintptr_t
-aioobThunk(MyThread* t);
+uintptr_t aioobThunk(MyThread* t);
 
-uintptr_t
-stackOverflowThunk(MyThread* t);
+uintptr_t stackOverflowThunk(MyThread* t);
 
-uintptr_t
-virtualThunk(MyThread* t, unsigned index);
+uintptr_t virtualThunk(MyThread* t, unsigned index);
 
-bool
-unresolved(MyThread* t, uintptr_t methodAddress);
+bool unresolved(MyThread* t, uintptr_t methodAddress);
 
 uintptr_t methodAddress(Thread* t, GcMethod* method)
 {
@@ -2323,8 +2362,8 @@ int64_t findInterfaceMethodFromInstance(MyThread* t,
                                         object instance)
 {
   if (instance) {
-    return prepareMethodForCall
-      (t, findInterfaceMethod(t, method, objectClass(t, instance)));
+    return prepareMethodForCall(
+        t, findInterfaceMethod(t, method, objectClass(t, instance)));
   } else {
     throwNew(t, GcNullPointerException::Type);
   }
@@ -2420,15 +2459,17 @@ int64_t getJClassFromReference(MyThread* t, GcPair* pair)
                    cast<GcReference>(t, pair->second())->name())));
 }
 
-unsigned
-traceSize(Thread* t)
+unsigned traceSize(Thread* t)
 {
-  class Counter: public Processor::StackVisitor {
+  class Counter : public Processor::StackVisitor {
    public:
-    Counter(): count(0) { }
+    Counter() : count(0)
+    {
+    }
 
-    virtual bool visit(Processor::StackWalker*) {
-      ++ count;
+    virtual bool visit(Processor::StackWalker*)
+    {
+      ++count;
       return true;
     }
 
@@ -2442,8 +2483,7 @@ traceSize(Thread* t)
          + (counter.count * pad(GcTraceElement::FixedSize));
 }
 
-void NO_RETURN
-throwArithmetic(MyThread* t)
+void NO_RETURN throwArithmetic(MyThread* t)
 {
   if (ensure(t, GcArithmeticException::FixedSize + traceSize(t))) {
     atomicOr(&(t->flags), Thread::TracingFlag);
@@ -2514,8 +2554,7 @@ uint64_t makeBlankObjectArrayFromReference(MyThread* t,
       length);
 }
 
-uint64_t
-makeBlankArray(MyThread* t, unsigned type, int32_t length)
+uint64_t makeBlankArray(MyThread* t, unsigned type, int32_t length)
 {
   if (length >= 0) {
     switch (type) {
@@ -2535,16 +2574,18 @@ makeBlankArray(MyThread* t, unsigned type, int32_t length)
       return reinterpret_cast<uintptr_t>(makeIntArray(t, length));
     case T_LONG:
       return reinterpret_cast<uintptr_t>(makeLongArray(t, length));
-    default: abort(t);
+    default:
+      abort(t);
     }
   } else {
     throwNew(t, GcNegativeArraySizeException::Type, "%d", length);
   }
 }
 
-uint64_t
-lookUpAddress(int32_t key, uintptr_t* start, int32_t count,
-              uintptr_t default_)
+uint64_t lookUpAddress(int32_t key,
+                       uintptr_t* start,
+                       int32_t count,
+                       uintptr_t default_)
 {
   int32_t bottom = 0;
   int32_t top = count;
@@ -2565,8 +2606,7 @@ lookUpAddress(int32_t key, uintptr_t* start, int32_t count,
   return default_;
 }
 
-void
-setMaybeNull(MyThread* t, object o, unsigned offset, object value)
+void setMaybeNull(MyThread* t, object o, unsigned offset, object value)
 {
   if (LIKELY(o)) {
     setField(t, o, offset, value);
@@ -2575,8 +2615,7 @@ setMaybeNull(MyThread* t, object o, unsigned offset, object value)
   }
 }
 
-void
-acquireMonitorForObject(MyThread* t, object o)
+void acquireMonitorForObject(MyThread* t, object o)
 {
   if (LIKELY(o)) {
     acquire(t, o);
@@ -2585,8 +2624,7 @@ acquireMonitorForObject(MyThread* t, object o)
   }
 }
 
-void
-acquireMonitorForObjectOnEntrance(MyThread* t, object o)
+void acquireMonitorForObjectOnEntrance(MyThread* t, object o)
 {
   if (LIKELY(o)) {
     t->methodLockIsClean = false;
@@ -2597,8 +2635,7 @@ acquireMonitorForObjectOnEntrance(MyThread* t, object o)
   }
 }
 
-void
-releaseMonitorForObject(MyThread* t, object o)
+void releaseMonitorForObject(MyThread* t, object o)
 {
   if (LIKELY(o)) {
     release(t, o);
@@ -2640,9 +2677,8 @@ uint64_t makeMultidimensionalArray(MyThread* t,
                                    int32_t dimensions,
                                    int32_t offset)
 {
-  return reinterpret_cast<uintptr_t>
-    (makeMultidimensionalArray2
-     (t, class_, static_cast<uintptr_t*>(t->stack) + offset, dimensions));
+  return reinterpret_cast<uintptr_t>(makeMultidimensionalArray2(
+      t, class_, static_cast<uintptr_t*>(t->stack) + offset, dimensions));
 }
 
 uint64_t makeMultidimensionalArrayFromReference(MyThread* t,
@@ -2659,8 +2695,7 @@ uint64_t makeMultidimensionalArrayFromReference(MyThread* t,
       offset);
 }
 
-void NO_RETURN
-throwArrayIndexOutOfBounds(MyThread* t)
+void NO_RETURN throwArrayIndexOutOfBounds(MyThread* t)
 {
   if (ensure(t, GcArrayIndexOutOfBoundsException::FixedSize + traceSize(t))) {
     atomicOr(&(t->flags), Thread::TracingFlag);
@@ -2674,8 +2709,7 @@ throwArrayIndexOutOfBounds(MyThread* t)
   }
 }
 
-void NO_RETURN
-throwStackOverflow(MyThread* t)
+void NO_RETURN throwStackOverflow(MyThread* t)
 {
   throwNew(t, GcStackOverflowError::Type);
 }
@@ -2960,8 +2994,7 @@ uint64_t getJClass64(Thread* t, GcClass* class_)
   return reinterpret_cast<uintptr_t>(getJClass(t, class_));
 }
 
-void
-gcIfNecessary(MyThread* t)
+void gcIfNecessary(MyThread* t)
 {
   stress(t);
 
@@ -2977,8 +3010,7 @@ void idleIfNecessary(MyThread* t)
   }
 }
 
-unsigned
-resultSize(MyThread* t, unsigned code)
+unsigned resultSize(MyThread* t, unsigned code)
 {
   switch (code) {
   case ByteField:
@@ -3024,12 +3056,12 @@ ir::Value* popField(MyThread* t, Frame* frame, int code)
   case ObjectField:
     return frame->pop(ir::Type::object());
 
-  default: abort(t);
+  default:
+    abort(t);
   }
 }
 
-bool
-useLongJump(MyThread* t, uintptr_t target)
+bool useLongJump(MyThread* t, uintptr_t target)
 {
   uintptr_t reach = t->arch->maximumImmediateJump();
   FixedAllocator* a = codeAllocator(t);
@@ -3039,10 +3071,11 @@ useLongJump(MyThread* t, uintptr_t target)
   assertT(t, end - start < reach);
 
   return (target > end && (target - start) > reach)
-    or (target < start && (end - target) > reach);
+         or (target < start && (end - target) > reach);
 }
 
-void compileSafePoint(MyThread* t, Compiler* c, Frame* frame) {
+void compileSafePoint(MyThread* t, Compiler* c, Frame* frame)
+{
   c->call(c->constant(getThunk(t, idleIfNecessaryThunk), ir::Type::iptr()),
           0,
           frame->trace(0, 0),
@@ -3060,7 +3093,8 @@ void compileDirectInvoke(MyThread* t,
 {
   avian::codegen::Compiler* c = frame->c;
 
-  unsigned flags = (avian::codegen::TailCalls and tailCall ? Compiler::TailJump : 0);
+  unsigned flags
+      = (avian::codegen::TailCalls and tailCall ? Compiler::TailJump : 0);
   unsigned traceFlags;
 
   if (addressPromise == 0 and useLongJump(t, methodAddress(t, target))) {
@@ -3081,9 +3115,9 @@ void compileDirectInvoke(MyThread* t,
 
       TraceElement* trace = frame->trace(target, traceFlags);
 
-      avian::codegen::Promise* returnAddressPromise = new
-        (frame->context->zone.allocate(sizeof(TraceElementPromise)))
-        TraceElementPromise(t->m->system, trace);
+      avian::codegen::Promise* returnAddressPromise
+          = new (frame->context->zone.allocate(sizeof(TraceElementPromise)))
+          TraceElementPromise(t->m->system, trace);
 
       frame->stackCall(
           c->promiseConstant(returnAddressPromise, ir::Type::iptr()),
@@ -3137,7 +3171,8 @@ bool compileDirectInvoke(MyThread* t,
            or (not classNeedsInit(t, target->class_())))
           and (not(avian::codegen::TailCalls and tailCall
                    and (target->flags() & ACC_NATIVE)))) {
-        avian::codegen::Promise* p = new(bc->zone) avian::codegen::ListenPromise(t->m->system, bc->zone);
+        avian::codegen::Promise* p = new (bc->zone)
+            avian::codegen::ListenPromise(t->m->system, bc->zone);
 
         PROTECT(t, target);
         object pointer = makePointer(t, p);
@@ -3228,8 +3263,7 @@ void compileDirectAbstractInvoke(MyThread* t,
       tailCall);
 }
 
-void
-handleMonitorEvent(MyThread* t, Frame* frame, intptr_t function)
+void handleMonitorEvent(MyThread* t, Frame* frame, intptr_t function)
 {
   avian::codegen::Compiler* c = frame->c;
   GcMethod* method = frame->context->method;
@@ -3255,8 +3289,7 @@ handleMonitorEvent(MyThread* t, Frame* frame, intptr_t function)
   }
 }
 
-void
-handleEntrance(MyThread* t, Frame* frame)
+void handleEntrance(MyThread* t, Frame* frame)
 {
   GcMethod* method = frame->context->method;
 
@@ -3271,15 +3304,13 @@ handleEntrance(MyThread* t, Frame* frame)
     frame->set(index, ir::Type::object());
   }
 
-  handleMonitorEvent
-    (t, frame, getThunk(t, acquireMonitorForObjectOnEntranceThunk));
+  handleMonitorEvent(
+      t, frame, getThunk(t, acquireMonitorForObjectOnEntranceThunk));
 }
 
-void
-handleExit(MyThread* t, Frame* frame)
+void handleExit(MyThread* t, Frame* frame)
 {
-  handleMonitorEvent
-    (t, frame, getThunk(t, releaseMonitorForObjectThunk));
+  handleMonitorEvent(t, frame, getThunk(t, releaseMonitorForObjectThunk));
 }
 
 bool inTryBlock(MyThread* t UNUSED, GcCode* code, unsigned ip)
@@ -3290,9 +3321,7 @@ bool inTryBlock(MyThread* t UNUSED, GcCode* code, unsigned ip)
     unsigned length = table->length();
     for (unsigned i = 0; i < length; ++i) {
       uint64_t eh = table->body()[i];
-      if (ip >= exceptionHandlerStart(eh)
-          and ip < exceptionHandlerEnd(eh))
-      {
+      if (ip >= exceptionHandlerStart(eh) and ip < exceptionHandlerEnd(eh)) {
         return true;
       }
     }
@@ -3393,8 +3422,9 @@ bool isReferenceTailCall(MyThread* t,
                     calleeReference->spec());
 }
 
-lir::TernaryOperation toCompilerJumpOp(MyThread* t, unsigned instruction) {
-  switch(instruction) {
+lir::TernaryOperation toCompilerJumpOp(MyThread* t, unsigned instruction)
+{
+  switch (instruction) {
   case ifeq:
   case if_icmpeq:
   case if_acmpeq:
@@ -3465,7 +3495,7 @@ lir::TernaryOperation toCompilerFloatJumpOp(MyThread* t,
                                             unsigned instruction,
                                             bool lessIfUnordered)
 {
-  switch(instruction) {
+  switch (instruction) {
   case ifeq:
     return lir::JumpIfFloatEqual;
   case ifne:
@@ -3527,10 +3557,8 @@ bool floatBranch(MyThread* t,
   case ifge:
   case iflt:
   case ifle:
-    c->condJump(toCompilerFloatJumpOp(t, instruction, lessIfUnordered),
-                a,
-                b,
-                target);
+    c->condJump(
+        toCompilerFloatJumpOp(t, instruction, lessIfUnordered), a, b, target);
     break;
 
   default:
@@ -3694,50 +3722,59 @@ unsigned targetFieldOffset(Context* context, GcField* field)
 
 class Stack {
  public:
-  class MyResource: public Thread::AutoResource {
+  class MyResource : public Thread::AutoResource {
    public:
-    MyResource(Stack* s): AutoResource(s->thread), s(s) { }
+    MyResource(Stack* s) : AutoResource(s->thread), s(s)
+    {
+    }
 
-    virtual void release() {
+    virtual void release()
+    {
       s->zone.dispose();
     }
 
     Stack* s;
   };
 
-  Stack(MyThread* t):
-    thread(t),
-    zone(t->m->system, t->m->heap, 0),
-    resource(this)
-  { }
+  Stack(MyThread* t)
+      : thread(t), zone(t->m->system, t->m->heap, 0), resource(this)
+  {
+  }
 
-  ~Stack() {
+  ~Stack()
+  {
     zone.dispose();
   }
 
-  void pushValue(uintptr_t v) {
+  void pushValue(uintptr_t v)
+  {
     *static_cast<uintptr_t*>(push(BytesPerWord)) = v;
   }
 
-  uintptr_t peekValue(unsigned offset) {
+  uintptr_t peekValue(unsigned offset)
+  {
     return *static_cast<uintptr_t*>(peek((offset + 1) * BytesPerWord));
   }
 
-  uintptr_t popValue() {
+  uintptr_t popValue()
+  {
     uintptr_t v = peekValue(0);
     pop(BytesPerWord);
     return v;
   }
 
-  void* push(unsigned size) {
+  void* push(unsigned size)
+  {
     return zone.allocate(size);
   }
 
-  void* peek(unsigned size) {
+  void* peek(unsigned size)
+  {
     return zone.peek(size);
   }
 
-  void pop(unsigned size) {
+  void pop(unsigned size)
+  {
     zone.pop(size);
   }
 
@@ -3763,16 +3800,19 @@ class SwitchState {
         bottom(bottom),
         top(top),
         index(0)
-  { }
-
-  Frame* frame() {
-    return reinterpret_cast<Frame*>
-      (reinterpret_cast<uint8_t*>(this) - pad(count * 4) - pad(sizeof(Frame)));
+  {
   }
 
-  uint32_t* ipTable() {
-    return reinterpret_cast<uint32_t*>
-      (reinterpret_cast<uint8_t*>(this) - pad(count * 4));
+  Frame* frame()
+  {
+    return reinterpret_cast<Frame*>(reinterpret_cast<uint8_t*>(this)
+                                    - pad(count * 4) - pad(sizeof(Frame)));
+  }
+
+  uint32_t* ipTable()
+  {
+    return reinterpret_cast<uint32_t*>(reinterpret_cast<uint8_t*>(this)
+                                       - pad(count * 4));
   }
 
   Compiler::State* state;
@@ -3835,18 +3875,12 @@ lir::TernaryOperation toCompilerBinaryOp(MyThread* t, unsigned instruction)
   }
 }
 
-void
-compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
-        int exceptionHandlerStart = -1)
+void compile(MyThread* t,
+             Frame* initialFrame,
+             unsigned initialIp,
+             int exceptionHandlerStart = -1)
 {
-  enum {
-    Return,
-    Unbranch,
-    Unsubroutine,
-    Untable0,
-    Untable1,
-    Unswitch
-  };
+  enum { Return, Unbranch, Unsubroutine, Untable0, Untable1, Unswitch };
 
   Frame* frame = initialFrame;
   avian::codegen::Compiler* c = frame->c;
@@ -3857,14 +3891,13 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
   unsigned newIp;
   stack.pushValue(Return);
 
-
- start:
-   ir::Type* stackMap
-       = static_cast<ir::Type*>(stack.push(stackSize * sizeof(ir::Type)));
+start:
+  ir::Type* stackMap
+      = static_cast<ir::Type*>(stack.push(stackSize * sizeof(ir::Type)));
   frame = new (stack.push(sizeof(Frame))) Frame(frame, stackMap);
 
- loop:
-   GcCode* code = context->method->code();
+loop:
+  GcCode* code = context->method->code();
   PROTECT(t, code);
 
   while (ip < code->length()) {
@@ -3891,7 +3924,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
               c->threadRegister());
     }
 
-//     fprintf(stderr, "ip: %d map: %ld\n", ip, *(frame->map));
+    //     fprintf(stderr, "ip: %d map: %ld\n", ip, *(frame->map));
 
     if (DebugInstructions) {
       unsigned startingIp = ip;
@@ -4156,7 +4189,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
     case areturn: {
       handleExit(t, frame);
       c->return_(frame->pop(ir::Type::object()));
-    } goto next;
+    }
+      goto next;
 
     case arraylength: {
       frame->push(ir::Type::i4(),
@@ -4198,7 +4232,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
               target);
 
       c->nullaryOp(lir::Trap);
-    } goto next;
+    }
+      goto next;
 
     case bipush:
       frame->push(
@@ -4630,7 +4665,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
       uint32_t newIp = (ip - 3) + offset;
       assertT(t, newIp < code->length());
 
-      if(newIp <= ip) {
+      if (newIp <= ip) {
         compileSafePoint(t, c, frame);
       }
 
@@ -4643,7 +4678,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
       uint32_t newIp = (ip - 5) + offset;
       assertT(t, newIp < code->length());
 
-      if(newIp <= ip) {
+      if (newIp <= ip) {
         compileSafePoint(t, c, frame);
       }
 
@@ -4757,7 +4792,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
       newIp = (ip - 3) + offset;
       assertT(t, newIp < code->length());
 
-      if(newIp <= ip) {
+      if (newIp <= ip) {
         compileSafePoint(t, c, frame);
       }
 
@@ -4766,7 +4801,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
       ir::Value* target = frame->machineIpValue(newIp);
 
       c->condJump(toCompilerJumpOp(t, instruction), a, b, target);
-    } goto branch;
+    }
+      goto branch;
 
     case if_icmpeq:
     case if_icmpne:
@@ -4778,7 +4814,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
       newIp = (ip - 3) + offset;
       assertT(t, newIp < code->length());
 
-      if(newIp <= ip) {
+      if (newIp <= ip) {
         compileSafePoint(t, c, frame);
       }
 
@@ -4787,7 +4823,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
       ir::Value* target = frame->machineIpValue(newIp);
 
       c->condJump(toCompilerJumpOp(t, instruction), a, b, target);
-    } goto branch;
+    }
+      goto branch;
 
     case ifeq:
     case ifne:
@@ -4801,7 +4838,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
 
       ir::Value* target = frame->machineIpValue(newIp);
 
-      if(newIp <= ip) {
+      if (newIp <= ip) {
         compileSafePoint(t, c, frame);
       }
 
@@ -4809,7 +4846,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
       ir::Value* b = frame->pop(ir::Type::i4());
 
       c->condJump(toCompilerJumpOp(t, instruction), a, b, target);
-    } goto branch;
+    }
+      goto branch;
 
     case ifnull:
     case ifnonnull: {
@@ -4817,7 +4855,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
       newIp = (ip - 3) + offset;
       assertT(t, newIp < code->length());
 
-      if(newIp <= ip) {
+      if (newIp <= ip) {
         compileSafePoint(t, c, frame);
       }
 
@@ -4826,7 +4864,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
       ir::Value* target = frame->machineIpValue(newIp);
 
       c->condJump(toCompilerJumpOp(t, instruction), a, b, target);
-    } goto branch;
+    }
+      goto branch;
 
     case iinc: {
       uint8_t index = code->body()[ip++];
@@ -4998,8 +5037,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
         bool tailCall = isTailCall(t, code, ip, context->method, target);
 
         if (UNLIKELY(methodAbstract(t, target))) {
-          compileDirectAbstractInvoke
-            (t, frame, getMethodAddressThunk, target, tailCall);
+          compileDirectAbstractInvoke(
+              t, frame, getMethodAddressThunk, target, tailCall);
         } else {
           compileDirectInvoke(t, frame, target, tailCall);
         }
@@ -5141,7 +5180,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
     case freturn: {
       handleExit(t, frame);
       c->return_(frame->pop(ir::Type::f4()));
-    } goto next;
+    }
+      goto next;
 
     case istore:
       frame->store(ir::Type::i4(), code->body()[ip++]);
@@ -5391,7 +5431,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
     case lookupswitch: {
       int32_t base = ip - 1;
 
-      ip = (ip + 3) & ~3; // pad to four byte boundary
+      ip = (ip + 3) & ~3;  // pad to four byte boundary
 
       ir::Value* key = frame->pop(ir::Type::i4());
 
@@ -5405,8 +5445,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
             frame->addressPromise(frame->machineIp(defaultIp)));
 
         avian::codegen::Promise* start = 0;
-        uint32_t* ipTable = static_cast<uint32_t*>
-          (stack.push(sizeof(uint32_t) * pairCount));
+        uint32_t* ipTable
+            = static_cast<uint32_t*>(stack.push(sizeof(uint32_t) * pairCount));
         for (int32_t i = 0; i < pairCount; ++i) {
           unsigned index = ip + (i * 8);
           int32_t key = codeReadInt32(t, code, index);
@@ -5443,8 +5483,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
                                  address)
                    : address);
 
-        new (stack.push(sizeof(SwitchState))) SwitchState
-          (c->saveState(), pairCount, defaultIp, 0, 0, 0, 0);
+        new (stack.push(sizeof(SwitchState)))
+            SwitchState(c->saveState(), pairCount, defaultIp, 0, 0, 0, 0);
 
         goto switchloop;
       } else {
@@ -5476,7 +5516,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
     case dreturn: {
       handleExit(t, frame);
       c->return_(frame->popLarge(ir::Type::f8()));
-    } goto next;
+    }
+      goto next;
 
     case lshl:
     case lshr:
@@ -5571,9 +5612,9 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
       }
 
       unsigned offset
-        = localOffset
-        (t, localSize(t, context->method) + c->topOfStack(), context->method)
-        + t->arch->frameReturnAddressSize();
+          = localOffset(t,
+                        localSize(t, context->method) + c->topOfStack(),
+                        context->method) + t->arch->frameReturnAddressSize();
 
       ir::Value* result
           = c->call(c->constant(getThunk(t, thunk), ir::Type::iptr()),
@@ -5642,7 +5683,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
                           length));
     } break;
 
-    case nop: break;
+    case nop:
+      break;
 
     case pop_:
       frame->popFootprint(1);
@@ -5696,8 +5738,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
 
         if (field->flags() & ACC_VOLATILE) {
           if (TargetBytesPerWord == 4
-              and (fieldCode == DoubleField or fieldCode == LongField))
-          {
+              and (fieldCode == DoubleField or fieldCode == LongField)) {
             PROTECT(t, field);
 
             c->call(c->constant(getThunk(t, acquireMonitorForObjectThunk),
@@ -5796,13 +5837,13 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
           }
           break;
 
-        default: abort(t);
+        default:
+          abort(t);
         }
 
         if (field->flags() & ACC_VOLATILE) {
           if (TargetBytesPerWord == 4
-              and (fieldCode == DoubleField or fieldCode == LongField))
-          {
+              and (fieldCode == DoubleField or fieldCode == LongField)) {
             c->call(c->constant(getThunk(t, releaseMonitorForObjectThunk),
                                 ir::Type::iptr()),
                     0,
@@ -5921,7 +5962,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
           }
         } break;
 
-        default: abort(t);
+        default:
+          abort(t);
         }
       }
     } break;
@@ -5956,7 +5998,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
     case tableswitch: {
       int32_t base = ip - 1;
 
-      ip = (ip + 3) & ~3; // pad to four byte boundary
+      ip = (ip + 3) & ~3;  // pad to four byte boundary
 
       uint32_t defaultIp = base + codeReadInt32(t, code, ip);
       assertT(t, defaultIp < code->length());
@@ -5966,8 +6008,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
 
       avian::codegen::Promise* start = 0;
       unsigned count = top - bottom + 1;
-      uint32_t* ipTable = static_cast<uint32_t*>
-        (stack.push(sizeof(uint32_t) * count));
+      uint32_t* ipTable
+          = static_cast<uint32_t*>(stack.push(sizeof(uint32_t) * count));
       for (int32_t i = 0; i < top - bottom + 1; ++i) {
         unsigned index = ip + (i * 4);
         uint32_t newIp = base + codeReadInt32(t, code, index);
@@ -5992,12 +6034,13 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
 
       c->save(ir::Type::i4(), key);
 
-      new (stack.push(sizeof(SwitchState))) SwitchState
-        (c->saveState(), count, defaultIp, key, start, bottom, top);
+      new (stack.push(sizeof(SwitchState))) SwitchState(
+          c->saveState(), count, defaultIp, key, start, bottom, top);
 
       stack.pushValue(Untable0);
       ip = defaultIp;
-    } goto start;
+    }
+      goto start;
 
     case wide: {
       switch (code->body()[ip++]) {
@@ -6047,15 +6090,17 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
         ip = returnAddress;
       } break;
 
-      default: abort(t);
+      default:
+        abort(t);
       }
     } break;
 
-    default: abort(t);
+    default:
+      abort(t);
     }
   }
 
- next:
+next:
   frame->dispose();
   frame = 0;
   stack.pop(sizeof(Frame));
@@ -6077,8 +6122,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
     if (DebugInstructions) {
       fprintf(stderr, "Untable0\n");
     }
-    SwitchState* s = static_cast<SwitchState*>
-      (stack.peek(sizeof(SwitchState)));
+    SwitchState* s = static_cast<SwitchState*>(stack.peek(sizeof(SwitchState)));
 
     frame = s->frame();
 
@@ -6092,14 +6136,14 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
     c->save(ir::Type::i4(), s->key);
     ip = s->defaultIp;
     stack.pushValue(Untable1);
-  } goto start;
+  }
+    goto start;
 
   case Untable1: {
     if (DebugInstructions) {
       fprintf(stderr, "Untable1\n");
     }
-    SwitchState* s = static_cast<SwitchState*>
-      (stack.peek(sizeof(SwitchState)));
+    SwitchState* s = static_cast<SwitchState*>(stack.peek(sizeof(SwitchState)));
 
     frame = s->frame();
 
@@ -6130,20 +6174,21 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
                    ir::Type::iptr()));
 
     s->state = c->saveState();
-  } goto switchloop;
+  }
+    goto switchloop;
 
   case Unswitch: {
     if (DebugInstructions) {
       fprintf(stderr, "Unswitch\n");
     }
-    SwitchState* s = static_cast<SwitchState*>
-      (stack.peek(sizeof(SwitchState)));
+    SwitchState* s = static_cast<SwitchState*>(stack.peek(sizeof(SwitchState)));
 
     frame = s->frame();
 
-    c->restoreState
-      (static_cast<SwitchState*>(stack.peek(sizeof(SwitchState)))->state);
-  } goto switchloop;
+    c->restoreState(
+        static_cast<SwitchState*>(stack.peek(sizeof(SwitchState)))->state);
+  }
+    goto switchloop;
 
   case Unsubroutine: {
     if (DebugInstructions) {
@@ -6153,31 +6198,31 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
     unsigned start = stack.popValue();
     frame = reinterpret_cast<Frame*>(stack.peek(sizeof(Frame)));
     frame->endSubroutine(start);
-  } goto loop;
+  }
+    goto loop;
 
   default:
     abort(t);
   }
 
- switchloop: {
-    SwitchState* s = static_cast<SwitchState*>
-      (stack.peek(sizeof(SwitchState)));
+switchloop : {
+  SwitchState* s = static_cast<SwitchState*>(stack.peek(sizeof(SwitchState)));
 
-    if (s->index < s->count) {
-      ip = s->ipTable()[s->index++];
-      stack.pushValue(Unswitch);
-      goto start;
-    } else {
-      ip = s->defaultIp;
-      unsigned count = s->count * 4;
-      stack.pop(sizeof(SwitchState));
-      stack.pop(count);
-      frame = reinterpret_cast<Frame*>(stack.peek(sizeof(Frame)));
-      goto loop;
-    }
+  if (s->index < s->count) {
+    ip = s->ipTable()[s->index++];
+    stack.pushValue(Unswitch);
+    goto start;
+  } else {
+    ip = s->defaultIp;
+    unsigned count = s->count * 4;
+    stack.pop(sizeof(SwitchState));
+    stack.pop(count);
+    frame = reinterpret_cast<Frame*>(stack.peek(sizeof(Frame)));
+    goto loop;
   }
+}
 
- branch:
+branch:
   stack.pushValue(reinterpret_cast<uintptr_t>(c->saveState()));
   stack.pushValue(ip);
   stack.pushValue(Unbranch);
@@ -6187,19 +6232,21 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp,
 
 FILE* compileLog = 0;
 
-void
-logCompile(MyThread* t, const void* code, unsigned size, const char* class_,
-           const char* name, const char* spec);
+void logCompile(MyThread* t,
+                const void* code,
+                unsigned size,
+                const char* class_,
+                const char* name,
+                const char* spec);
 
-int
-resolveIpForwards(Context* context, int start, int end)
+int resolveIpForwards(Context* context, int start, int end)
 {
   if (start < 0) {
     start = 0;
   }
 
   while (start < end and context->visitTable[start] == 0) {
-    ++ start;
+    ++start;
   }
 
   if (start >= end) {
@@ -6209,15 +6256,14 @@ resolveIpForwards(Context* context, int start, int end)
   }
 }
 
-int
-resolveIpBackwards(Context* context, int start, int end)
+int resolveIpBackwards(Context* context, int start, int end)
 {
   if (start >= static_cast<int>(context->method->code()->length()
                                 * (context->subroutineCount + 1))) {
     start = context->method->code()->length();
   } else {
     while (start >= end and context->visitTable[start] == 0) {
-      -- start;
+      --start;
     }
   }
 
@@ -6405,8 +6451,7 @@ GcLineNumberTable* translateLineNumberTable(MyThread* t,
   }
 }
 
-void
-printSet(uintptr_t* m, unsigned limit)
+void printSet(uintptr_t* m, unsigned limit)
 {
   if (limit) {
     for (unsigned i = 0; i < 32; ++i) {
@@ -6419,12 +6464,11 @@ printSet(uintptr_t* m, unsigned limit)
   }
 }
 
-void calculateTryCatchRoots(
-    Context* context,
-    uintptr_t* roots,
-    unsigned mapSize,
-    unsigned start,
-    unsigned end)
+void calculateTryCatchRoots(Context* context,
+                            uintptr_t* roots,
+                            unsigned mapSize,
+                            unsigned start,
+                            unsigned end)
 {
   memset(roots, 0xFF, mapSize * BytesPerWord);
 
@@ -6528,8 +6572,7 @@ unsigned calculateFrameMaps(MyThread* t,
 
           if ((eventIndex == length
                or context->eventLog.get(eventIndex) == PopContextEvent)
-              and newRoots != tableRoots[wi])
-          {
+              and newRoots != tableRoots[wi]) {
             if (DebugFrameMaps) {
               fprintf(stderr, "dirty roots!\n");
             }
@@ -6579,7 +6622,8 @@ unsigned calculateFrameMaps(MyThread* t,
     } break;
 
     case TraceEvent: {
-      TraceElement* te; context->eventLog.get(eventIndex, &te, BytesPerWord);
+      TraceElement* te;
+      context->eventLog.get(eventIndex, &te, BytesPerWord);
       if (DebugFrameMaps) {
         fprintf(stderr, " trace roots at ip %3d: ", ip);
         printSet(RUNTIME_ARRAY_BODY(roots), mapSize);
@@ -6608,11 +6652,12 @@ unsigned calculateFrameMaps(MyThread* t,
       eventIndex += BytesPerWord;
     } break;
 
-    default: abort(t);
+    default:
+      abort(t);
     }
   }
 
- exit:
+exit:
   if (resultRoots and ip != -1) {
     if (DebugFrameMaps) {
       fprintf(stderr, "result roots at ip %3d: ", ip);
@@ -6626,8 +6671,7 @@ unsigned calculateFrameMaps(MyThread* t,
   return eventIndex;
 }
 
-int
-compareTraceElementPointers(const void* va, const void* vb)
+int compareTraceElementPointers(const void* va, const void* vb)
 {
   TraceElement* a = *static_cast<TraceElement* const*>(va);
   TraceElement* b = *static_cast<TraceElement* const*>(vb);
@@ -6646,12 +6690,14 @@ unsigned simpleFrameMapTableSize(MyThread* t, GcMethod* method, GcIntArray* map)
   return ceilingDivide(map->length() * size, 32 + size);
 }
 
-uint8_t*
-finish(MyThread* t, FixedAllocator* allocator, avian::codegen::Assembler* a, const char* name,
-       unsigned length)
+uint8_t* finish(MyThread* t,
+                FixedAllocator* allocator,
+                avian::codegen::Assembler* a,
+                const char* name,
+                unsigned length)
 {
-  uint8_t* start = static_cast<uint8_t*>
-    (allocator->allocate(length, TargetBytesPerWord));
+  uint8_t* start
+      = static_cast<uint8_t*>(allocator->allocate(length, TargetBytesPerWord));
 
   a->setDestination(start);
   a->write();
@@ -6661,14 +6707,12 @@ finish(MyThread* t, FixedAllocator* allocator, avian::codegen::Assembler* a, con
   return start;
 }
 
-void
-setBit(int32_t* dst, unsigned index)
+void setBit(int32_t* dst, unsigned index)
 {
   dst[index / 32] |= static_cast<int32_t>(1) << (index % 32);
 }
 
-void
-clearBit(int32_t* dst, unsigned index)
+void clearBit(int32_t* dst, unsigned index)
 {
   dst[index / 32] &= ~(static_cast<int32_t>(1) << (index % 32));
 }
@@ -6708,20 +6752,19 @@ void copyFrameMap(int32_t* dst,
 
 class FrameMapTableHeader {
  public:
-  FrameMapTableHeader(unsigned indexCount):
-    indexCount(indexCount)
-  { }
+  FrameMapTableHeader(unsigned indexCount) : indexCount(indexCount)
+  {
+  }
 
   unsigned indexCount;
 };
 
 class FrameMapTableIndexElement {
  public:
-  FrameMapTableIndexElement(int offset, unsigned base, unsigned path):
-    offset(offset),
-    base(base),
-    path(path)
-  { }
+  FrameMapTableIndexElement(int offset, unsigned base, unsigned path)
+      : offset(offset), base(base), path(path)
+  {
+  }
 
   int offset;
   unsigned base;
@@ -6730,11 +6773,10 @@ class FrameMapTableIndexElement {
 
 class FrameMapTablePath {
  public:
-  FrameMapTablePath(unsigned stackIndex, unsigned elementCount, unsigned next):
-    stackIndex(stackIndex),
-    elementCount(elementCount),
-    next(next)
-  { }
+  FrameMapTablePath(unsigned stackIndex, unsigned elementCount, unsigned next)
+      : stackIndex(stackIndex), elementCount(elementCount), next(next)
+  {
+  }
 
   unsigned stackIndex;
   unsigned elementCount;
@@ -6775,8 +6817,7 @@ GcIntArray* makeSimpleFrameMapTable(MyThread* t,
   return table;
 }
 
-void
-finish(MyThread* t, FixedAllocator* allocator, Context* context)
+void finish(MyThread* t, FixedAllocator* allocator, Context* context)
 {
   avian::codegen::Compiler* c = context->compiler;
 
@@ -6815,10 +6856,10 @@ finish(MyThread* t, FixedAllocator* allocator, Context* context)
   unsigned codeSize = c->resolve(allocator->memory.begin() + allocator->offset);
 
   unsigned total = pad(codeSize, TargetBytesPerWord)
-    + pad(c->poolSize(), TargetBytesPerWord);
+                   + pad(c->poolSize(), TargetBytesPerWord);
 
-  target_uintptr_t* code = static_cast<target_uintptr_t*>
-    (allocator->allocate(total, TargetBytesPerWord));
+  target_uintptr_t* code = static_cast<target_uintptr_t*>(
+      allocator->allocate(total, TargetBytesPerWord));
   uint8_t* start = reinterpret_cast<uint8_t*>(code);
 
   context->executableAllocator = allocator;
@@ -6859,9 +6900,9 @@ finish(MyThread* t, FixedAllocator* allocator, Context* context)
   if (bc) {
     for (avian::codegen::DelayedPromise* p = bc->addresses;
          p != bc->addressSentinal;
-         p = p->next)
-    {
-      p->basis = new(bc->zone) avian::codegen::ResolvedPromise(p->basis->value());
+         p = p->next) {
+      p->basis = new (bc->zone)
+          avian::codegen::ResolvedPromise(p->basis->value());
     }
   }
 
@@ -6902,19 +6943,19 @@ finish(MyThread* t, FixedAllocator* allocator, Context* context)
       assertT(t, index < context->traceLogCount);
 
       if (p->address) {
-
         RUNTIME_ARRAY_BODY(elements)[index++] = p;
 
         if (p->target) {
-          insertCallNode
-            (t, makeCallNode
-             (t, p->address->value(), p->target, p->flags, 0));
+          insertCallNode(
+              t, makeCallNode(t, p->address->value(), p->target, p->flags, 0));
         }
       }
     }
 
-    qsort(RUNTIME_ARRAY_BODY(elements), index,
-          sizeof(TraceElement*), compareTraceElementPointers);
+    qsort(RUNTIME_ARRAY_BODY(elements),
+          index,
+          sizeof(TraceElement*),
+          compareTraceElementPointers);
 
     GcIntArray* map = makeSimpleFrameMapTable(
         t, context, start, RUNTIME_ARRAY_BODY(elements), index);
@@ -6946,12 +6987,11 @@ finish(MyThread* t, FixedAllocator* allocator, Context* context)
 #endif
 }
 
-void
-compile(MyThread* t, Context* context)
+void compile(MyThread* t, Context* context)
 {
   avian::codegen::Compiler* c = context->compiler;
 
-//   fprintf(stderr, "compiling %s.%s%s\n",
+  //   fprintf(stderr, "compiling %s.%s%s\n",
   //           context->method->class_()->name()->body().begin(),
   //           context->method->name()->body().begin(),
   //           context->method->spec()->body().begin());
@@ -7041,8 +7081,8 @@ compile(MyThread* t, Context* context)
                                   duplicatedBaseIp + exceptionHandlerStart(eh),
                                   duplicatedBaseIp + exceptionHandlerEnd(eh));
 
-          if ((not RUNTIME_ARRAY_BODY(visited)[i])and start
-              >= 0 and context->visitTable[start]) {
+          if ((not RUNTIME_ARRAY_BODY(visited)[i]) and start >= 0
+              and context->visitTable[start]) {
             RUNTIME_ARRAY_BODY(visited)[i] = true;
             progress = true;
 
@@ -7084,17 +7124,17 @@ compile(MyThread* t, Context* context)
   free(stackMap);
 }
 
-void
-updateCall(MyThread* t, avian::codegen::lir::UnaryOperation op, void* returnAddress, void* target)
+void updateCall(MyThread* t,
+                avian::codegen::lir::UnaryOperation op,
+                void* returnAddress,
+                void* target)
 {
   t->arch->updateCall(op, returnAddress, target);
 }
 
-void*
-compileMethod2(MyThread* t, void* ip);
+void* compileMethod2(MyThread* t, void* ip);
 
-uint64_t
-compileMethod(MyThread* t)
+uint64_t compileMethod(MyThread* t)
 {
   void* ip;
   if (t->tailAddress) {
@@ -7140,8 +7180,7 @@ void* compileVirtualMethod2(MyThread* t, GcClass* class_, unsigned index)
   return address;
 }
 
-uint64_t
-compileVirtualMethod(MyThread* t)
+uint64_t compileVirtualMethod(MyThread* t)
 {
   GcClass* class_ = objectClass(t, static_cast<object>(t->virtualCallTarget));
   t->virtualCallTarget = 0;
@@ -7154,10 +7193,11 @@ compileVirtualMethod(MyThread* t)
 
 uint64_t invokeNativeFast(MyThread* t, GcMethod* method, void* function)
 {
-  FastNativeFunction f; memcpy(&f, &function, sizeof(void*));
-  return f(t, method,
-           static_cast<uintptr_t*>(t->stack)
-           + t->arch->frameFooterSize()
+  FastNativeFunction f;
+  memcpy(&f, &function, sizeof(void*));
+  return f(t,
+           method,
+           static_cast<uintptr_t*>(t->stack) + t->arch->frameFooterSize()
            + t->arch->frameReturnAddressSize());
 }
 
@@ -7167,7 +7207,7 @@ uint64_t invokeNativeSlow(MyThread* t, GcMethod* method, void* function)
 
   unsigned footprint = method->parameterFootprint() + 1;
   if (method->flags() & ACC_STATIC) {
-    ++ footprint;
+    ++footprint;
   }
   unsigned count = method->parameterCount() + 2;
 
@@ -7179,9 +7219,8 @@ uint64_t invokeNativeSlow(MyThread* t, GcMethod* method, void* function)
   RUNTIME_ARRAY_BODY(args)[argOffset++] = reinterpret_cast<uintptr_t>(t);
   RUNTIME_ARRAY_BODY(types)[typeOffset++] = POINTER_TYPE;
 
-  uintptr_t* sp = static_cast<uintptr_t*>(t->stack)
-    + t->arch->frameFooterSize()
-    + t->arch->frameReturnAddressSize();
+  uintptr_t* sp = static_cast<uintptr_t*>(t->stack) + t->arch->frameFooterSize()
+                  + t->arch->frameReturnAddressSize();
 
   GcJclass* jclass = 0;
   PROTECT(t, jclass);
@@ -7189,10 +7228,9 @@ uint64_t invokeNativeSlow(MyThread* t, GcMethod* method, void* function)
   if (method->flags() & ACC_STATIC) {
     jclass = getJClass(t, method->class_());
     RUNTIME_ARRAY_BODY(args)[argOffset++]
-      = reinterpret_cast<uintptr_t>(&jclass);
+        = reinterpret_cast<uintptr_t>(&jclass);
   } else {
-    RUNTIME_ARRAY_BODY(args)[argOffset++]
-      = reinterpret_cast<uintptr_t>(sp++);
+    RUNTIME_ARRAY_BODY(args)[argOffset++] = reinterpret_cast<uintptr_t>(sp++);
   }
   RUNTIME_ARRAY_BODY(types)[typeOffset++] = POINTER_TYPE;
 
@@ -7201,7 +7239,7 @@ uint64_t invokeNativeSlow(MyThread* t, GcMethod* method, void* function)
 
   while (it.hasNext()) {
     unsigned type = RUNTIME_ARRAY_BODY(types)[typeOffset++]
-      = fieldType(t, fieldCode(t, *it.next()));
+        = fieldType(t, fieldCode(t, *it.next()));
 
     switch (type) {
     case INT8_TYPE:
@@ -7220,15 +7258,15 @@ uint64_t invokeNativeSlow(MyThread* t, GcMethod* method, void* function)
 
     case POINTER_TYPE: {
       if (*sp) {
-        RUNTIME_ARRAY_BODY(args)[argOffset++]
-          = reinterpret_cast<uintptr_t>(sp);
+        RUNTIME_ARRAY_BODY(args)[argOffset++] = reinterpret_cast<uintptr_t>(sp);
       } else {
         RUNTIME_ARRAY_BODY(args)[argOffset++] = 0;
       }
-      ++ sp;
+      ++sp;
     } break;
 
-    default: abort(t);
+    default:
+      abort(t);
     }
   }
 
@@ -7253,7 +7291,8 @@ uint64_t invokeNativeSlow(MyThread* t, GcMethod* method, void* function)
 
   Reference* reference = t->reference;
 
-  { ENTER(t, Thread::IdleState);
+  {
+    ENTER(t, Thread::IdleState);
 
     bool noThrow = t->checkpoint->noThrow;
     t->checkpoint->noThrow = true;
@@ -7312,15 +7351,17 @@ uint64_t invokeNativeSlow(MyThread* t, GcMethod* method, void* function)
     break;
 
   case ObjectField:
-    result = static_cast<uintptr_t>(result) ? *reinterpret_cast<uintptr_t*>
-      (static_cast<uintptr_t>(result)) : 0;
+    result = static_cast<uintptr_t>(result)
+                 ? *reinterpret_cast<uintptr_t*>(static_cast<uintptr_t>(result))
+                 : 0;
     break;
 
   case VoidField:
     result = 0;
     break;
 
-  default: abort(t);
+  default:
+    abort(t);
   }
 
   while (t->reference != reference) {
@@ -7340,8 +7381,7 @@ uint64_t invokeNative2(MyThread* t, GcMethod* method)
   }
 }
 
-uint64_t
-invokeNative(MyThread* t)
+uint64_t invokeNative(MyThread* t)
 {
   if (t->trace->nativeMethod == 0) {
     void* ip;
@@ -7376,10 +7416,9 @@ invokeNative(MyThread* t)
 
   if (avian::codegen::TailCalls
       and t->arch->argumentFootprint(parameterFootprint)
-      > t->arch->stackAlignmentInWords())
-  {
+          > t->arch->stackAlignmentInWords()) {
     stack += t->arch->argumentFootprint(parameterFootprint)
-      - t->arch->stackAlignmentInWords();
+             - t->arch->stackAlignmentInWords();
   }
 
   stack += t->arch->frameReturnAddressSize();
@@ -7447,9 +7486,13 @@ void visitStackAndLocals(MyThread* t,
 
     int32_t* map;
     unsigned offset;
-    findFrameMap
-      (t, stack, method, difference
-       (ip, reinterpret_cast<void*>(methodAddress(t, method))), &map, &offset);
+    findFrameMap(
+        t,
+        stack,
+        method,
+        difference(ip, reinterpret_cast<void*>(methodAddress(t, method))),
+        &map,
+        &offset);
 
     for (unsigned i = 0; i < count; ++i) {
       int j = offset + i;
@@ -7460,13 +7503,10 @@ void visitStackAndLocals(MyThread* t,
   }
 }
 
-void
-visitArgument(MyThread* t, Heap::Visitor* v, void* stack, unsigned index)
+void visitArgument(MyThread* t, Heap::Visitor* v, void* stack, unsigned index)
 {
-  v->visit(static_cast<object*>(stack)
-           + index
-           + t->arch->frameReturnAddressSize()
-           + t->arch->frameFooterSize());
+  v->visit(static_cast<object*>(stack) + index
+           + t->arch->frameReturnAddressSize() + t->arch->frameFooterSize());
 }
 
 void visitArguments(MyThread* t,
@@ -7495,14 +7535,13 @@ void visitArguments(MyThread* t,
       break;
 
     default:
-      ++ index;
+      ++index;
       break;
     }
   }
 }
 
-void
-visitStack(MyThread* t, Heap::Visitor* v)
+void visitStack(MyThread* t, Heap::Visitor* v)
 {
   void* ip = getIp(t);
   void* stack = t->stack;
@@ -7621,7 +7660,8 @@ void callContinuation(MyThread* t,
 int8_t* returnSpec(MyThread* t, GcMethod* method)
 {
   int8_t* s = method->spec()->body().begin();
-  while (*s and *s != ')') ++ s;
+  while (*s and *s != ')')
+    ++s;
   expect(t, *s == ')');
   return s + 1;
 }
@@ -7680,7 +7720,8 @@ void jumpAndInvoke(MyThread* t, GcMethod* method, void* stack, ...)
 
   unsigned argumentCount = method->parameterFootprint();
   THREAD_RUNTIME_ARRAY(t, uintptr_t, arguments, argumentCount);
-  va_list a; va_start(a, stack);
+  va_list a;
+  va_start(a, stack);
   for (unsigned i = 0; i < argumentCount; ++i) {
     RUNTIME_ARRAY_BODY(arguments)[i] = va_arg(a, uintptr_t);
   }
@@ -7690,14 +7731,14 @@ void jumpAndInvoke(MyThread* t, GcMethod* method, void* stack, ...)
 
   popResources(t);
 
-  vmJumpAndInvoke
-    (t, reinterpret_cast<void*>(methodAddress(t, method)),
-     stack,
-     argumentCount * BytesPerWord,
-     RUNTIME_ARRAY_BODY(arguments),
-     (t->arch->alignFrameSize(t->arch->argumentFootprint(argumentCount))
-      + t->arch->frameReturnAddressSize())
-     * BytesPerWord);
+  vmJumpAndInvoke(
+      t,
+      reinterpret_cast<void*>(methodAddress(t, method)),
+      stack,
+      argumentCount * BytesPerWord,
+      RUNTIME_ARRAY_BODY(arguments),
+      (t->arch->alignFrameSize(t->arch->argumentFootprint(argumentCount))
+       + t->arch->frameReturnAddressSize()) * BytesPerWord);
 }
 
 void callContinuation(MyThread* t,
@@ -7705,11 +7746,7 @@ void callContinuation(MyThread* t,
                       object result,
                       GcThrowable* exception)
 {
-  enum {
-    Call,
-    Unwind,
-    Rewind
-  } action;
+  enum { Call, Unwind, Rewind } action;
 
   GcContinuation* nextContinuation = 0;
 
@@ -7814,14 +7851,14 @@ void callContinuation(MyThread* t,
   }
 }
 
-void
-callWithCurrentContinuation(MyThread* t, object receiver)
+void callWithCurrentContinuation(MyThread* t, object receiver)
 {
   GcMethod* method = 0;
   void* ip = 0;
   void* stack = 0;
 
-  { PROTECT(t, receiver);
+  {
+    PROTECT(t, receiver);
 
     if (compileRoots(t)->receiveMethod() == 0) {
       GcMethod* m = resolveMethod(t,
@@ -7854,13 +7891,13 @@ callWithCurrentContinuation(MyThread* t, object receiver)
   jumpAndInvoke(t, method, stack, receiver, t->continuation);
 }
 
-void
-dynamicWind(MyThread* t, object before, object thunk, object after)
+void dynamicWind(MyThread* t, object before, object thunk, object after)
 {
   void* ip = 0;
   void* stack = 0;
 
-  { PROTECT(t, before);
+  {
+    PROTECT(t, before);
     PROTECT(t, thunk);
     PROTECT(t, after);
 
@@ -7897,15 +7934,20 @@ dynamicWind(MyThread* t, object before, object thunk, object after)
 
 class ArgumentList {
  public:
-  ArgumentList(Thread* t, uintptr_t* array, unsigned size, bool* objectMask,
-               object this_, const char* spec, bool indirectObjects,
-               va_list arguments):
-    t(static_cast<MyThread*>(t)),
-    array(array),
-    objectMask(objectMask),
-    size(size),
-    position(0),
-    protector(this)
+  ArgumentList(Thread* t,
+               uintptr_t* array,
+               unsigned size,
+               bool* objectMask,
+               object this_,
+               const char* spec,
+               bool indirectObjects,
+               va_list arguments)
+      : t(static_cast<MyThread*>(t)),
+        array(array),
+        objectMask(objectMask),
+        size(size),
+        position(0),
+        protector(this)
   {
     if (this_) {
       addObject(this_);
@@ -7942,14 +7984,19 @@ class ArgumentList {
     }
   }
 
-  ArgumentList(Thread* t, uintptr_t* array, unsigned size, bool* objectMask,
-               object this_, const char* spec, const jvalue* arguments):
-    t(static_cast<MyThread*>(t)),
-    array(array),
-    objectMask(objectMask),
-    size(size),
-    position(0),
-    protector(this)
+  ArgumentList(Thread* t,
+               uintptr_t* array,
+               unsigned size,
+               bool* objectMask,
+               object this_,
+               const char* spec,
+               const jvalue* arguments)
+      : t(static_cast<MyThread*>(t)),
+        array(array),
+        objectMask(objectMask),
+        size(size),
+        position(0),
+        protector(this)
   {
     if (this_) {
       addObject(this_);
@@ -7983,14 +8030,19 @@ class ArgumentList {
     }
   }
 
-  ArgumentList(Thread* t, uintptr_t* array, unsigned size, bool* objectMask,
-               object this_, const char* spec, object arguments):
-    t(static_cast<MyThread*>(t)),
-    array(array),
-    objectMask(objectMask),
-    size(size),
-    position(0),
-    protector(this)
+  ArgumentList(Thread* t,
+               uintptr_t* array,
+               unsigned size,
+               bool* objectMask,
+               object this_,
+               const char* spec,
+               object arguments)
+      : t(static_cast<MyThread*>(t)),
+        array(array),
+        objectMask(objectMask),
+        size(size),
+        position(0),
+        protector(this)
   {
     if (this_) {
       addObject(this_);
@@ -8006,34 +8058,38 @@ class ArgumentList {
 
       case 'J':
       case 'D':
-        addLong(fieldAtOffset<int64_t>(objectArrayBody(t, arguments, index++), 8));
+        addLong(
+            fieldAtOffset<int64_t>(objectArrayBody(t, arguments, index++), 8));
         break;
 
       default:
         addInt(fieldAtOffset<int32_t>(objectArrayBody(t, arguments, index++),
-                             BytesPerWord));
+                                      BytesPerWord));
         break;
       }
     }
   }
 
-  void addObject(object v) {
+  void addObject(object v)
+  {
     assertT(t, position < size);
 
     array[position] = reinterpret_cast<uintptr_t>(v);
     objectMask[position] = true;
-    ++ position;
+    ++position;
   }
 
-  void addInt(uintptr_t v) {
+  void addInt(uintptr_t v)
+  {
     assertT(t, position < size);
 
     array[position] = v;
     objectMask[position] = false;
-    ++ position;
+    ++position;
   }
 
-  void addLong(uint64_t v) {
+  void addLong(uint64_t v)
+  {
     assertT(t, position < size - 1);
 
     memcpy(array + position, &v, 8);
@@ -8050,11 +8106,14 @@ class ArgumentList {
   unsigned size;
   unsigned position;
 
-  class MyProtector: public Thread::Protector {
+  class MyProtector : public Thread::Protector {
    public:
-    MyProtector(ArgumentList* list): Protector(list->t), list(list) { }
+    MyProtector(ArgumentList* list) : Protector(list->t), list(list)
+    {
+    }
 
-    virtual void visit(Heap::Visitor* v) {
+    virtual void visit(Heap::Visitor* v)
+    {
       for (unsigned i = 0; i < list->position; ++i) {
         if (list->objectMask[i]) {
           v->visit(reinterpret_cast<object*>(list->array + i));
@@ -8089,7 +8148,9 @@ object invoke(Thread* thread, GcMethod* method, ArgumentList* arguments)
     throwNew(t, GcStackOverflowError::Type);
   }
 
-  THREAD_RESOURCE(t, uintptr_t, stackLimit,
+  THREAD_RESOURCE(t,
+                  uintptr_t,
+                  stackLimit,
                   static_cast<MyThread*>(t)->stackLimit = stackLimit);
 
   unsigned returnCode = method->returnCode();
@@ -8097,20 +8158,21 @@ object invoke(Thread* thread, GcMethod* method, ArgumentList* arguments)
 
   uint64_t result;
 
-  { MyThread::CallTrace trace(t, method);
+  {
+    MyThread::CallTrace trace(t, method);
 
     MyCheckpoint checkpoint(t);
 
     assertT(t, arguments->position == arguments->size);
 
-    result = vmInvoke
-      (t, reinterpret_cast<void*>(methodAddress(t, method)),
-       arguments->array,
-       arguments->position * BytesPerWord,
-       t->arch->alignFrameSize
-       (t->arch->argumentFootprint(arguments->position))
-       * BytesPerWord,
-       returnType);
+    result = vmInvoke(
+        t,
+        reinterpret_cast<void*>(methodAddress(t, method)),
+        arguments->array,
+        arguments->position * BytesPerWord,
+        t->arch->alignFrameSize(t->arch->argumentFootprint(arguments->position))
+        * BytesPerWord,
+        returnType);
   }
 
   if (t->exception) {
@@ -8154,7 +8216,7 @@ object invoke(Thread* thread, GcMethod* method, ArgumentList* arguments)
   return r;
 }
 
-class SignalHandler: public SignalRegistrar::Handler {
+class SignalHandler : public SignalRegistrar::Handler {
  public:
   typedef GcThrowable* (GcRoots::*ExceptionGetter)();
   SignalHandler(Gc::Type type, ExceptionGetter exc, unsigned fixedSize)
@@ -8162,7 +8224,9 @@ class SignalHandler: public SignalRegistrar::Handler {
   {
   }
 
-  virtual bool handleSignal(void** ip, void** frame, void** stack,
+  virtual bool handleSignal(void** ip,
+                            void** frame,
+                            void** stack,
                             void** thread)
   {
     MyThread* t = static_cast<MyThread*>(m->localThread->get());
@@ -8171,10 +8235,12 @@ class SignalHandler: public SignalRegistrar::Handler {
       if (node) {
         // add one to the IP since findLineNumber will subtract one
         // when we make the trace:
-        MyThread::TraceContext context
-          (t, static_cast<uint8_t*>(*ip) + 1,
-           static_cast<void**>(*stack) - t->arch->frameReturnAddressSize(),
-           t->continuation, t->trace);
+        MyThread::TraceContext context(
+            t,
+            static_cast<uint8_t*>(*ip) + 1,
+            static_cast<void**>(*stack) - t->arch->frameReturnAddressSize(),
+            t->continuation,
+            t->trace);
 
         if (ensure(t, pad(fixedSize) + traceSize(t))) {
           atomicOr(&(t->flags), Thread::TracingFlag);
@@ -8212,34 +8278,31 @@ class SignalHandler: public SignalRegistrar::Handler {
   unsigned fixedSize;
 };
 
-bool
-isThunk(MyThread* t, void* ip);
+bool isThunk(MyThread* t, void* ip);
 
-bool
-isVirtualThunk(MyThread* t, void* ip);
+bool isVirtualThunk(MyThread* t, void* ip);
 
-bool
-isThunkUnsafeStack(MyThread* t, void* ip);
+bool isThunkUnsafeStack(MyThread* t, void* ip);
 
-void
-boot(MyThread* t, BootImage* image, uint8_t* code);
+void boot(MyThread* t, BootImage* image, uint8_t* code);
 
 class MyProcessor;
 
-MyProcessor*
-processor(MyThread* t);
+MyProcessor* processor(MyThread* t);
 
-void
-compileThunks(MyThread* t, FixedAllocator* allocator);
+void compileThunks(MyThread* t, FixedAllocator* allocator);
 
 class CompilationHandlerList {
-public:
-  CompilationHandlerList(CompilationHandlerList* next, Processor::CompilationHandler* handler):
-    next(next),
-    handler(handler) {}
+ public:
+  CompilationHandlerList(CompilationHandlerList* next,
+                         Processor::CompilationHandler* handler)
+      : next(next), handler(handler)
+  {
+  }
 
-  void dispose(Allocator* allocator) {
-    if(this) {
+  void dispose(Allocator* allocator)
+  {
+    if (this) {
       next->dispose(allocator);
       handler->dispose();
       allocator->free(this, sizeof(*this));
@@ -8250,10 +8313,12 @@ public:
   Processor::CompilationHandler* handler;
 };
 
-template<class T, class C>
-int checkConstant(MyThread* t, size_t expected, T C::* field, const char* name) {
-  size_t actual = reinterpret_cast<uint8_t*>(&(t->*field)) - reinterpret_cast<uint8_t*>(t);
-  if(expected != actual) {
+template <class T, class C>
+int checkConstant(MyThread* t, size_t expected, T C::*field, const char* name)
+{
+  size_t actual = reinterpret_cast<uint8_t*>(&(t->*field))
+                  - reinterpret_cast<uint8_t*>(t);
+  if (expected != actual) {
     fprintf(stderr,
             "constant mismatch (%s): \n\tconstant says: %d\n\tc++ compiler "
             "says: %d\n",
@@ -8265,17 +8330,18 @@ int checkConstant(MyThread* t, size_t expected, T C::* field, const char* name)
   return 0;
 }
 
-class MyProcessor: public Processor {
+class MyProcessor : public Processor {
  public:
   class Thunk {
    public:
-    Thunk():
-      start(0), frameSavedOffset(0), length(0)
-    { }
+    Thunk() : start(0), frameSavedOffset(0), length(0)
+    {
+    }
 
-    Thunk(uint8_t* start, unsigned frameSavedOffset, unsigned length):
-      start(start), frameSavedOffset(frameSavedOffset), length(length)
-    { }
+    Thunk(uint8_t* start, unsigned frameSavedOffset, unsigned length)
+        : start(start), frameSavedOffset(frameSavedOffset), length(length)
+    {
+    }
 
     uint8_t* start;
     unsigned frameSavedOffset;
@@ -8317,8 +8383,8 @@ class MyProcessor: public Processor {
     thunkTable[compileMethodIndex] = voidPointer(local::compileMethod);
     thunkTable[compileVirtualMethodIndex] = voidPointer(compileVirtualMethod);
     thunkTable[invokeNativeIndex] = voidPointer(invokeNative);
-    thunkTable[throwArrayIndexOutOfBoundsIndex] = voidPointer
-      (throwArrayIndexOutOfBounds);
+    thunkTable[throwArrayIndexOutOfBoundsIndex]
+        = voidPointer(throwArrayIndexOutOfBounds);
     thunkTable[throwStackOverflowIndex] = voidPointer(throwStackOverflow);
 
     using namespace avian::codegen::runtime;
@@ -8332,17 +8398,16 @@ class MyProcessor: public Processor {
     // implicitly sign- or zero-extended).  We'll use this property
     // later to determine the maximum size of a thunk in the thunk
     // table.
-    thunkTable[dummyIndex] = reinterpret_cast<void*>
-      (static_cast<uintptr_t>(UINT64_C(0x5555555555555555)));
+    thunkTable[dummyIndex] = reinterpret_cast<void*>(
+        static_cast<uintptr_t>(UINT64_C(0x5555555555555555)));
 
     signals.setCrashDumpDirectory(crashDumpDirectory);
   }
 
   virtual Thread* makeThread(Machine* m, GcThread* javaThread, Thread* parent)
   {
-    MyThread* t = new (m->heap->allocate(sizeof(MyThread)))
-      MyThread(m, javaThread, static_cast<MyThread*>(parent),
-               useNativeFeatures);
+    MyThread* t = new (m->heap->allocate(sizeof(MyThread))) MyThread(
+        m, javaThread, static_cast<MyThread*>(parent), useNativeFeatures);
 
     t->heapImage = heapImage;
     t->codeImage = codeImage;
@@ -8404,7 +8469,7 @@ class MyProcessor: public Processor {
                           &MyThread::stackLimit,
                           "TARGET_THREAD_STACKLIMIT");
 
-    if(mismatches > 0) {
+    if (mismatches > 0) {
       fprintf(stderr, "%d constant mismatches\n", mismatches);
       abort(t);
     }
@@ -8500,14 +8565,13 @@ class MyProcessor: public Processor {
   {
     PROTECT(t, c);
     for (int i = c->length() - 1; i >= 0; --i) {
-      void* thunk = reinterpret_cast<void*>
-        (virtualThunk(static_cast<MyThread*>(t), i));
+      void* thunk
+          = reinterpret_cast<void*>(virtualThunk(static_cast<MyThread*>(t), i));
       c->vtable()[i] = thunk;
     }
   }
 
-  virtual void
-  visitObjects(Thread* vmt, Heap::Visitor* v)
+  virtual void visitObjects(Thread* vmt, Heap::Visitor* v)
   {
     MyThread* t = static_cast<MyThread*>(vmt);
 
@@ -8531,8 +8595,7 @@ class MyProcessor: public Processor {
     visitStack(t, v);
   }
 
-  virtual void
-  walkStack(Thread* vmt, StackVisitor* v)
+  virtual void walkStack(Thread* vmt, StackVisitor* v)
   {
     MyThread* t = static_cast<MyThread*>(vmt);
 
@@ -8545,8 +8608,7 @@ class MyProcessor: public Processor {
     return findLineNumber(static_cast<MyThread*>(vmt), method, ip);
   }
 
-  virtual object*
-  makeLocalReference(Thread* vmt, object o)
+  virtual object* makeLocalReference(Thread* vmt, object o)
   {
     if (o) {
       MyThread* t = static_cast<MyThread*>(vmt);
@@ -8560,7 +8622,7 @@ class MyProcessor: public Processor {
       }
 
       Reference* r = new (t->m->heap->allocate(sizeof(Reference)))
-        Reference(o, &(t->reference), false);
+          Reference(o, &(t->reference), false);
 
       acquire(t, r);
 
@@ -8570,28 +8632,24 @@ class MyProcessor: public Processor {
     }
   }
 
-  virtual void
-  disposeLocalReference(Thread* t, object* r)
+  virtual void disposeLocalReference(Thread* t, object* r)
   {
     if (r) {
       release(t, reinterpret_cast<Reference*>(r));
     }
   }
 
-  virtual bool
-  pushLocalFrame(Thread* vmt, unsigned)
+  virtual bool pushLocalFrame(Thread* vmt, unsigned)
   {
     MyThread* t = static_cast<MyThread*>(vmt);
 
-    t->referenceFrame = new
-      (t->m->heap->allocate(sizeof(List<Reference*>)))
-      List<Reference*>(t->reference, t->referenceFrame);
+    t->referenceFrame = new (t->m->heap->allocate(sizeof(List<Reference*>)))
+        List<Reference*>(t->reference, t->referenceFrame);
 
     return true;
   }
 
-  virtual void
-  popLocalFrame(Thread* vmt)
+  virtual void popLocalFrame(Thread* vmt)
   {
     MyThread* t = static_cast<MyThread*>(vmt);
 
@@ -8624,14 +8682,20 @@ class MyProcessor: public Processor {
     unsigned size = method->parameterFootprint();
     THREAD_RUNTIME_ARRAY(t, uintptr_t, array, size);
     THREAD_RUNTIME_ARRAY(t, bool, objectMask, size);
-    ArgumentList list
-      (t, RUNTIME_ARRAY_BODY(array), size, RUNTIME_ARRAY_BODY(objectMask),
-       this_, spec, arguments);
+    ArgumentList list(t,
+                      RUNTIME_ARRAY_BODY(array),
+                      size,
+                      RUNTIME_ARRAY_BODY(objectMask),
+                      this_,
+                      spec,
+                      arguments);
 
     PROTECT(t, method);
 
     compile(static_cast<MyThread*>(t),
-            local::codeAllocator(static_cast<MyThread*>(t)), 0, method);
+            local::codeAllocator(static_cast<MyThread*>(t)),
+            0,
+            method);
 
     return local::invoke(t, method, &list);
   }
@@ -8656,14 +8720,20 @@ class MyProcessor: public Processor {
     unsigned size = method->parameterFootprint();
     THREAD_RUNTIME_ARRAY(t, uintptr_t, array, size);
     THREAD_RUNTIME_ARRAY(t, bool, objectMask, size);
-    ArgumentList list
-      (t, RUNTIME_ARRAY_BODY(array), size, RUNTIME_ARRAY_BODY(objectMask),
-       this_, spec, arguments);
+    ArgumentList list(t,
+                      RUNTIME_ARRAY_BODY(array),
+                      size,
+                      RUNTIME_ARRAY_BODY(objectMask),
+                      this_,
+                      spec,
+                      arguments);
 
     PROTECT(t, method);
 
     compile(static_cast<MyThread*>(t),
-            local::codeAllocator(static_cast<MyThread*>(t)), 0, method);
+            local::codeAllocator(static_cast<MyThread*>(t)),
+            0,
+            method);
 
     return local::invoke(t, method, &list);
   }
@@ -8689,14 +8759,21 @@ class MyProcessor: public Processor {
     unsigned size = method->parameterFootprint();
     THREAD_RUNTIME_ARRAY(t, uintptr_t, array, size);
     THREAD_RUNTIME_ARRAY(t, bool, objectMask, size);
-    ArgumentList list
-      (t, RUNTIME_ARRAY_BODY(array), size, RUNTIME_ARRAY_BODY(objectMask),
-       this_, spec, indirectObjects, arguments);
+    ArgumentList list(t,
+                      RUNTIME_ARRAY_BODY(array),
+                      size,
+                      RUNTIME_ARRAY_BODY(objectMask),
+                      this_,
+                      spec,
+                      indirectObjects,
+                      arguments);
 
     PROTECT(t, method);
 
     compile(static_cast<MyThread*>(t),
-            local::codeAllocator(static_cast<MyThread*>(t)), 0, method);
+            local::codeAllocator(static_cast<MyThread*>(t)),
+            0,
+            method);
 
     return local::invoke(t, method, &list);
   }
@@ -8718,9 +8795,14 @@ class MyProcessor: public Processor {
     unsigned size = parameterFootprint(t, methodSpec, this_ == 0);
     THREAD_RUNTIME_ARRAY(t, uintptr_t, array, size);
     THREAD_RUNTIME_ARRAY(t, bool, objectMask, size);
-    ArgumentList list
-      (t, RUNTIME_ARRAY_BODY(array), size, RUNTIME_ARRAY_BODY(objectMask),
-       this_, methodSpec, false, arguments);
+    ArgumentList list(t,
+                      RUNTIME_ARRAY_BODY(array),
+                      size,
+                      RUNTIME_ARRAY_BODY(objectMask),
+                      this_,
+                      methodSpec,
+                      false,
+                      arguments);
 
     GcMethod* method
         = resolveMethod(t, loader, className, methodName, methodSpec);
@@ -8737,7 +8819,8 @@ class MyProcessor: public Processor {
     return local::invoke(t, method, &list);
   }
 
-  virtual void dispose(Thread* vmt) {
+  virtual void dispose(Thread* vmt)
+  {
     MyThread* t = static_cast<MyThread*>(vmt);
 
     while (t->reference) {
@@ -8747,10 +8830,10 @@ class MyProcessor: public Processor {
     t->arch->release();
 
     t->m->heap->free(t, sizeof(*t));
-
   }
 
-  virtual void dispose() {
+  virtual void dispose()
+  {
     if (codeAllocator.memory.begin()) {
 #if !defined(AVIAN_AOT_ONLY)
       s->freeExecutable(codeAllocator.memory.begin(),
@@ -8769,18 +8852,21 @@ class MyProcessor: public Processor {
     allocator->free(this, sizeof(*this));
   }
 
-  virtual object getStackTrace(Thread* vmt, Thread* vmTarget) {
+  virtual object getStackTrace(Thread* vmt, Thread* vmTarget)
+  {
     MyThread* t = static_cast<MyThread*>(vmt);
     MyThread* target = static_cast<MyThread*>(vmTarget);
     MyProcessor* p = this;
 
-    class Visitor: public System::ThreadVisitor {
+    class Visitor : public System::ThreadVisitor {
      public:
-      Visitor(MyThread* t, MyProcessor* p, MyThread* target):
-        t(t), p(p), target(target), trace(0)
-      { }
+      Visitor(MyThread* t, MyProcessor* p, MyThread* target)
+          : t(t), p(p), target(target), trace(0)
+      {
+      }
 
-      virtual void visit(void* ip, void* stack, void* link) {
+      virtual void visit(void* ip, void* stack, void* link)
+      {
         MyThread::TraceContext c(target, link);
 
         if (methodForIp(t, ip)) {
@@ -8800,10 +8886,8 @@ class MyProcessor: public Processor {
           // MyThread::continuation or MyThread::trace
           c.ip = 0;
           c.stack = 0;
-        } else if (target->stack
-                   and (not isThunkUnsafeStack(t, ip))
-                   and (not isVirtualThunk(t, ip)))
-        {
+        } else if (target->stack and (not isThunkUnsafeStack(t, ip))
+                   and (not isVirtualThunk(t, ip))) {
           // we caught the thread in a thunk or native code, and the
           // saved stack pointer indicates the most recent Java frame
           // on the stack
@@ -8860,7 +8944,8 @@ class MyProcessor: public Processor {
     codeAllocator.memory = code;
   }
 
-  virtual void addCompilationHandler(CompilationHandler* handler) {
+  virtual void addCompilationHandler(CompilationHandler* handler)
+  {
     compilationHandlers
         = new (allocator->allocate(sizeof(CompilationHandlerList)))
         CompilationHandlerList(compilationHandlers, handler);
@@ -8884,14 +8969,16 @@ class MyProcessor: public Processor {
     *addresses = bootContext.addresses;
   }
 
-  virtual void visitRoots(Thread* t, HeapWalker* w) {
+  virtual void visitRoots(Thread* t, HeapWalker* w)
+  {
     bootImage->methodTree = w->visitRoot(compileRoots(t)->methodTree());
     bootImage->methodTreeSentinal
         = w->visitRoot(compileRoots(t)->methodTreeSentinal());
     bootImage->virtualThunks = w->visitRoot(compileRoots(t)->virtualThunks());
   }
 
-  virtual void normalizeVirtualThunks(Thread* t) {
+  virtual void normalizeVirtualThunks(Thread* t)
+  {
     GcWordArray* a = compileRoots(t)->virtualThunks();
     for (unsigned i = 0; i < a->length(); i += 2) {
       if (a->body()[i]) {
@@ -8901,12 +8988,13 @@ class MyProcessor: public Processor {
     }
   }
 
-  virtual unsigned* makeCallTable(Thread* t, HeapWalker* w) {
+  virtual unsigned* makeCallTable(Thread* t, HeapWalker* w)
+  {
     bootImage->codeSize = codeAllocator.offset;
     bootImage->callCount = callTableSize;
 
-    unsigned* table = static_cast<unsigned*>
-      (t->m->heap->allocate(callTableSize * sizeof(unsigned) * 2));
+    unsigned* table = static_cast<unsigned*>(
+        t->m->heap->allocate(callTableSize * sizeof(unsigned) * 2));
 
     unsigned index = 0;
     GcArray* callTable = compileRoots(t)->callTable();
@@ -8961,19 +9049,24 @@ class MyProcessor: public Processor {
 #else
     local::compileThunks(static_cast<MyThread*>(t), &codeAllocator);
 
-    if (not (image and code)) {
+    if (not(image and code)) {
       bootThunks = thunks;
     }
 #endif
 
     segFaultHandler.m = t->m;
-    expect(t, signals.registerHandler(SignalRegistrar::SegFault, &segFaultHandler));
+    expect(
+        t,
+        signals.registerHandler(SignalRegistrar::SegFault, &segFaultHandler));
 
     divideByZeroHandler.m = t->m;
-    expect(t, signals.registerHandler(SignalRegistrar::DivideByZero, &divideByZeroHandler));
+    expect(t,
+           signals.registerHandler(SignalRegistrar::DivideByZero,
+                                   &divideByZeroHandler));
   }
 
-  virtual void callWithCurrentContinuation(Thread* t, object receiver) {
+  virtual void callWithCurrentContinuation(Thread* t, object receiver)
+  {
     if (Continuations) {
       local::callWithCurrentContinuation(static_cast<MyThread*>(t), receiver);
     } else {
@@ -8981,8 +9074,7 @@ class MyProcessor: public Processor {
     }
   }
 
-  virtual void dynamicWind(Thread* t, object before, object thunk,
-                           object after)
+  virtual void dynamicWind(Thread* t, object before, object thunk, object after)
   {
     if (Continuations) {
       local::dynamicWind(static_cast<MyThread*>(t), before, thunk, after);
@@ -9013,7 +9105,9 @@ class MyProcessor: public Processor {
     }
   }
 
-  virtual void walkContinuationBody(Thread* t, Heap::Walker* w, object o,
+  virtual void walkContinuationBody(Thread* t,
+                                    Heap::Walker* w,
+                                    object o,
                                     unsigned start)
   {
     if (Continuations) {
@@ -9043,23 +9137,26 @@ class MyProcessor: public Processor {
   CompilationHandlerList* compilationHandlers;
 };
 
-const char*
-stringOrNull(const char* str) {
-  if(str) {
+const char* stringOrNull(const char* str)
+{
+  if (str) {
     return str;
   } else {
     return "(null)";
   }
 }
 
-size_t
-stringOrNullSize(const char* str) {
+size_t stringOrNullSize(const char* str)
+{
   return strlen(stringOrNull(str));
 }
 
-void
-logCompile(MyThread* t, const void* code, unsigned size, const char* class_,
-           const char* name, const char* spec)
+void logCompile(MyThread* t,
+                const void* code,
+                unsigned size,
+                const char* class_,
+                const char* name,
+                const char* spec)
 {
   static bool open = false;
   if (not open) {
@@ -9073,9 +9170,13 @@ logCompile(MyThread* t, const void* code, unsigned size, const char* class_,
   }
 
   if (compileLog) {
-    fprintf(compileLog, "%p,%p %s.%s%s\n",
-            code, static_cast<const uint8_t*>(code) + size,
-            class_, name, spec);
+    fprintf(compileLog,
+            "%p,%p %s.%s%s\n",
+            code,
+            static_cast<const uint8_t*>(code) + size,
+            class_,
+            name,
+            spec);
   }
 
   size_t nameLength = stringOrNullSize(class_) + stringOrNullSize(name)
@@ -9090,13 +9191,12 @@ logCompile(MyThread* t, const void* code, unsigned size, const char* class_,
           stringOrNull(spec));
 
   MyProcessor* p = static_cast<MyProcessor*>(t->m->processor);
-  for(CompilationHandlerList* h = p->compilationHandlers; h; h = h->next) {
+  for (CompilationHandlerList* h = p->compilationHandlers; h; h = h->next) {
     h->handler->compiled(code, 0, 0, RUNTIME_ARRAY_BODY(completeName));
   }
 }
 
-void*
-compileMethod2(MyThread* t, void* ip)
+void* compileMethod2(MyThread* t, void* ip)
 {
   GcCallNode* node = findCallNode(t, ip);
   GcMethod* target = node->target();
@@ -9115,12 +9215,14 @@ compileMethod2(MyThread* t, void* ip)
   MyProcessor* p = processor(t);
 
   bool updateCaller = updateIp < p->codeImage
-    or updateIp >= p->codeImage + p->codeImageSize;
+                      or updateIp >= p->codeImage + p->codeImageSize;
 
   uintptr_t address;
   if (target->flags() & ACC_NATIVE) {
     address = useLongJump(t, reinterpret_cast<uintptr_t>(ip))
-      or (not updateCaller) ? bootNativeThunk(t) : nativeThunk(t);
+                  or (not updateCaller)
+                  ? bootNativeThunk(t)
+                  : nativeThunk(t);
   } else {
     address = methodAddress(t, target);
   }
@@ -9145,38 +9247,34 @@ compileMethod2(MyThread* t, void* ip)
   return reinterpret_cast<void*>(address);
 }
 
-bool
-isThunk(MyProcessor::ThunkCollection* thunks, void* ip)
+bool isThunk(MyProcessor::ThunkCollection* thunks, void* ip)
 {
   uint8_t* thunkStart = thunks->default_.start;
-  uint8_t* thunkEnd = thunks->table.start
-    + (thunks->table.length * ThunkCount);
+  uint8_t* thunkEnd = thunks->table.start + (thunks->table.length * ThunkCount);
 
   return (reinterpret_cast<uintptr_t>(ip)
           >= reinterpret_cast<uintptr_t>(thunkStart)
           and reinterpret_cast<uintptr_t>(ip)
-          < reinterpret_cast<uintptr_t>(thunkEnd));
+              < reinterpret_cast<uintptr_t>(thunkEnd));
 }
 
-bool
-isThunk(MyThread* t, void* ip)
+bool isThunk(MyThread* t, void* ip)
 {
   MyProcessor* p = processor(t);
 
   return isThunk(&(p->thunks), ip) or isThunk(&(p->bootThunks), ip);
 }
 
-bool
-isThunkUnsafeStack(MyProcessor::Thunk* thunk, void* ip)
+bool isThunkUnsafeStack(MyProcessor::Thunk* thunk, void* ip)
 {
   return reinterpret_cast<uintptr_t>(ip)
-    >= reinterpret_cast<uintptr_t>(thunk->start)
-    and reinterpret_cast<uintptr_t>(ip)
-    < reinterpret_cast<uintptr_t>(thunk->start + thunk->frameSavedOffset);
+         >= reinterpret_cast<uintptr_t>(thunk->start)
+         and reinterpret_cast<uintptr_t>(ip)
+             < reinterpret_cast<uintptr_t>(thunk->start
+                                           + thunk->frameSavedOffset);
 }
 
-bool
-isThunkUnsafeStack(MyProcessor::ThunkCollection* thunks, void* ip)
+bool isThunkUnsafeStack(MyProcessor::ThunkCollection* thunks, void* ip)
 {
   const unsigned NamedThunkCount = 5;
 
@@ -9189,10 +9287,10 @@ isThunkUnsafeStack(MyProcessor::ThunkCollection* thunks, void* ip)
   table[4] = thunks->stackOverflow;
 
   for (unsigned i = 0; i < ThunkCount; ++i) {
-    new (table + NamedThunkCount + i) MyProcessor::Thunk
-      (thunks->table.start + (i * thunks->table.length),
-       thunks->table.frameSavedOffset,
-       thunks->table.length);
+    new (table + NamedThunkCount + i)
+        MyProcessor::Thunk(thunks->table.start + (i * thunks->table.length),
+                           thunks->table.frameSavedOffset,
+                           thunks->table.length);
   }
 
   for (unsigned i = 0; i < NamedThunkCount + ThunkCount; ++i) {
@@ -9204,8 +9302,7 @@ isThunkUnsafeStack(MyProcessor::ThunkCollection* thunks, void* ip)
   return false;
 }
 
-bool
-isVirtualThunk(MyThread* t, void* ip)
+bool isVirtualThunk(MyThread* t, void* ip)
 {
   GcWordArray* a = compileRoots(t)->virtualThunks();
   for (unsigned i = 0; i < a->length(); i += 2) {
@@ -9213,8 +9310,7 @@ isVirtualThunk(MyThread* t, void* ip)
     uintptr_t end = start + a->body()[i + 1];
 
     if (reinterpret_cast<uintptr_t>(ip) >= start
-        and reinterpret_cast<uintptr_t>(ip) < end)
-    {
+        and reinterpret_cast<uintptr_t>(ip) < end) {
       return true;
     }
   }
@@ -9222,14 +9318,12 @@ isVirtualThunk(MyThread* t, void* ip)
   return false;
 }
 
-bool
-isThunkUnsafeStack(MyThread* t, void* ip)
+bool isThunkUnsafeStack(MyThread* t, void* ip)
 {
   MyProcessor* p = processor(t);
 
-  return isThunk(t, ip)
-    and (isThunkUnsafeStack(&(p->thunks), ip)
-         or isThunkUnsafeStack(&(p->bootThunks), ip));
+  return isThunk(t, ip) and (isThunkUnsafeStack(&(p->thunks), ip)
+                             or isThunkUnsafeStack(&(p->bootThunks), ip));
 }
 
 GcCallNode* findCallNode(MyThread* t, void* address)
@@ -9305,7 +9399,7 @@ GcArray* insertCallNode(MyThread* t,
   PROTECT(t, table);
   PROTECT(t, node);
 
-  ++ (*size);
+  ++(*size);
 
   if (*size >= table->length() * 2) {
     table = resizeTable(t, table, table->length() * 2);
@@ -9413,8 +9507,10 @@ GcArray* makeCallTable(MyThread* t,
   return table;
 }
 
-void
-fixupHeap(MyThread* t UNUSED, uintptr_t* map, unsigned size, uintptr_t* heap)
+void fixupHeap(MyThread* t UNUSED,
+               uintptr_t* map,
+               unsigned size,
+               uintptr_t* heap)
 {
   for (unsigned word = 0; word < size; ++word) {
     uintptr_t w = map[word];
@@ -9454,11 +9550,10 @@ void resetClassRuntimeState(Thread* t,
     if (staticTable) {
       for (unsigned i = 0; i < singletonCount(t, staticTable); ++i) {
         if (singletonIsObject(t, staticTable, i)
-            and (reinterpret_cast<uintptr_t*>
-                 (singletonObject(t, staticTable, i)) < heap or
-                 reinterpret_cast<uintptr_t*>
-                 (singletonObject(t, staticTable, i)) > heap + heapSize))
-        {
+            and (reinterpret_cast<uintptr_t*>(
+                     singletonObject(t, staticTable, i)) < heap
+                 or reinterpret_cast<uintptr_t*>(singletonObject(
+                        t, staticTable, i)) > heap + heapSize)) {
           singletonObject(t, staticTable, i) = 0;
         }
       }
@@ -9531,30 +9626,26 @@ void fixupMethods(Thread* t,
   }
 }
 
-MyProcessor::Thunk
-thunkToThunk(const BootImage::Thunk& thunk, uint8_t* base)
+MyProcessor::Thunk thunkToThunk(const BootImage::Thunk& thunk, uint8_t* base)
 {
-  return MyProcessor::Thunk
-    (base + thunk.start, thunk.frameSavedOffset, thunk.length);
+  return MyProcessor::Thunk(
+      base + thunk.start, thunk.frameSavedOffset, thunk.length);
 }
 
-void
-findThunks(MyThread* t, BootImage* image, uint8_t* code)
+void findThunks(MyThread* t, BootImage* image, uint8_t* code)
 {
   MyProcessor* p = processor(t);
 
   p->bootThunks.default_ = thunkToThunk(image->thunks.default_, code);
   p->bootThunks.defaultVirtual
-    = thunkToThunk(image->thunks.defaultVirtual, code);
+      = thunkToThunk(image->thunks.defaultVirtual, code);
   p->bootThunks.native = thunkToThunk(image->thunks.native, code);
   p->bootThunks.aioob = thunkToThunk(image->thunks.aioob, code);
-  p->bootThunks.stackOverflow
-    = thunkToThunk(image->thunks.stackOverflow, code);
+  p->bootThunks.stackOverflow = thunkToThunk(image->thunks.stackOverflow, code);
   p->bootThunks.table = thunkToThunk(image->thunks.table, code);
 }
 
-void
-fixupVirtualThunks(MyThread* t, uint8_t* code)
+void fixupVirtualThunks(MyThread* t, uint8_t* code)
 {
   GcWordArray* a = compileRoots(t)->virtualThunks();
   for (unsigned i = 0; i < a->length(); i += 2) {
@@ -9564,8 +9655,7 @@ fixupVirtualThunks(MyThread* t, uint8_t* code)
   }
 }
 
-void
-boot(MyThread* t, BootImage* image, uint8_t* code)
+void boot(MyThread* t, BootImage* image, uint8_t* code)
 {
   assertT(t, image->magic == BootImage::Magic);
 
@@ -9574,11 +9664,11 @@ boot(MyThread* t, BootImage* image, uint8_t* code)
   unsigned* stringTable = appClassTable + image->appClassCount;
   unsigned* callTable = stringTable + image->stringCount;
 
-  uintptr_t* heapMap = reinterpret_cast<uintptr_t*>
-    (padWord(reinterpret_cast<uintptr_t>(callTable + (image->callCount * 2))));
+  uintptr_t* heapMap = reinterpret_cast<uintptr_t*>(
+      padWord(reinterpret_cast<uintptr_t>(callTable + (image->callCount * 2))));
 
-  unsigned heapMapSizeInWords = ceilingDivide
-    (heapMapSize(image->heapSize), BytesPerWord);
+  unsigned heapMapSizeInWords
+      = ceilingDivide(heapMapSize(image->heapSize), BytesPerWord);
   uintptr_t* heap = heapMap + heapMapSizeInWords;
 
   MyProcessor* p = static_cast<MyProcessor*>(t->m->processor);
@@ -9728,27 +9818,24 @@ boot(MyThread* t, BootImage* image, uint8_t* code)
   roots(t)->setBootstrapClassMap(t, map);
 }
 
-intptr_t
-getThunk(MyThread* t, Thunk thunk)
+intptr_t getThunk(MyThread* t, Thunk thunk)
 {
   MyProcessor* p = processor(t);
 
-  return reinterpret_cast<intptr_t>
-    (p->thunks.table.start + (thunk * p->thunks.table.length));
+  return reinterpret_cast<intptr_t>(p->thunks.table.start
+                                    + (thunk * p->thunks.table.length));
 }
 
-BootImage::Thunk
-thunkToThunk(const MyProcessor::Thunk& thunk, uint8_t* base)
+BootImage::Thunk thunkToThunk(const MyProcessor::Thunk& thunk, uint8_t* base)
 {
-  return BootImage::Thunk
-    (thunk.start - base, thunk.frameSavedOffset, thunk.length);
+  return BootImage::Thunk(
+      thunk.start - base, thunk.frameSavedOffset, thunk.length);
 }
 
 using avian::codegen::OperandInfo;
 namespace lir = avian::codegen::lir;
 
-void
-compileCall(MyThread* t, Context* c, ThunkIndex index, bool call = true)
+void compileCall(MyThread* t, Context* c, ThunkIndex index, bool call = true)
 {
   avian::codegen::Assembler* a = c->assembler;
 
@@ -9762,25 +9849,23 @@ compileCall(MyThread* t, Context* c, ThunkIndex index, bool call = true)
     a->apply(lir::Move,
              OperandInfo(TargetBytesPerWord, lir::MemoryOperand, &proc),
              OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &scratch));
-    a->apply
-      (call ? lir::Call : lir::Jump,
-       OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &scratch));
+    a->apply(call ? lir::Call : lir::Jump,
+             OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &scratch));
   } else {
-    lir::Constant proc
-      (new(&c->zone) avian::codegen::ResolvedPromise(reinterpret_cast<intptr_t>(t->thunkTable[index])));
+    lir::Constant proc(new (&c->zone) avian::codegen::ResolvedPromise(
+        reinterpret_cast<intptr_t>(t->thunkTable[index])));
 
-    a->apply
-      (call ? lir::LongCall : lir::LongJump,
-       OperandInfo(TargetBytesPerWord, lir::ConstantOperand, &proc));
+    a->apply(call ? lir::LongCall : lir::LongJump,
+             OperandInfo(TargetBytesPerWord, lir::ConstantOperand, &proc));
   }
 }
 
-void
-compileThunks(MyThread* t, FixedAllocator* allocator)
+void compileThunks(MyThread* t, FixedAllocator* allocator)
 {
   MyProcessor* p = processor(t);
 
-  { Context context(t);
+  {
+    Context context(t);
     avian::codegen::Assembler* a = context.assembler;
 
     a->saveFrame(TARGET_THREAD_STACK, TARGET_THREAD_IP);
@@ -9800,37 +9885,42 @@ compileThunks(MyThread* t, FixedAllocator* allocator)
 
     p->thunks.default_.length = a->endBlock(false)->resolve(0, 0);
 
-    p->thunks.default_.start = finish
-      (t, allocator, a, "default", p->thunks.default_.length);
+    p->thunks.default_.start
+        = finish(t, allocator, a, "default", p->thunks.default_.length);
   }
 
-  { Context context(t);
+  {
+    Context context(t);
     avian::codegen::Assembler* a = context.assembler;
 
     lir::Register class_(t->arch->virtualCallTarget());
-    lir::Memory virtualCallTargetSrc
-      (t->arch->stack(),
-       (t->arch->frameFooterSize() + t->arch->frameReturnAddressSize())
-       * TargetBytesPerWord);
+    lir::Memory virtualCallTargetSrc(
+        t->arch->stack(),
+        (t->arch->frameFooterSize() + t->arch->frameReturnAddressSize())
+        * TargetBytesPerWord);
 
     a->apply(lir::Move,
-             OperandInfo(TargetBytesPerWord, lir::MemoryOperand, &virtualCallTargetSrc),
+             OperandInfo(
+                 TargetBytesPerWord, lir::MemoryOperand, &virtualCallTargetSrc),
              OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &class_));
 
-    lir::Memory virtualCallTargetDst
-      (t->arch->thread(), TARGET_THREAD_VIRTUALCALLTARGET);
+    lir::Memory virtualCallTargetDst(t->arch->thread(),
+                                     TARGET_THREAD_VIRTUALCALLTARGET);
 
-    a->apply(lir::Move,
-             OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &class_),
-             OperandInfo(TargetBytesPerWord, lir::MemoryOperand, &virtualCallTargetDst));
+    a->apply(
+        lir::Move,
+        OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &class_),
+        OperandInfo(
+            TargetBytesPerWord, lir::MemoryOperand, &virtualCallTargetDst));
 
     lir::Register index(t->arch->virtualCallIndex());
-    lir::Memory virtualCallIndex
-      (t->arch->thread(), TARGET_THREAD_VIRTUALCALLINDEX);
+    lir::Memory virtualCallIndex(t->arch->thread(),
+                                 TARGET_THREAD_VIRTUALCALLINDEX);
 
-    a->apply(lir::Move,
-             OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &index),
-             OperandInfo(TargetBytesPerWord, lir::MemoryOperand, &virtualCallIndex));
+    a->apply(
+        lir::Move,
+        OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &index),
+        OperandInfo(TargetBytesPerWord, lir::MemoryOperand, &virtualCallIndex));
 
     a->saveFrame(TARGET_THREAD_STACK, TARGET_THREAD_IP);
 
@@ -9849,11 +9939,12 @@ compileThunks(MyThread* t, FixedAllocator* allocator)
 
     p->thunks.defaultVirtual.length = a->endBlock(false)->resolve(0, 0);
 
-    p->thunks.defaultVirtual.start = finish
-      (t, allocator, a, "defaultVirtual", p->thunks.defaultVirtual.length);
+    p->thunks.defaultVirtual.start = finish(
+        t, allocator, a, "defaultVirtual", p->thunks.defaultVirtual.length);
   }
 
-  { Context context(t);
+  {
+    Context context(t);
     avian::codegen::Assembler* a = context.assembler;
 
     a->saveFrame(TARGET_THREAD_STACK, TARGET_THREAD_IP);
@@ -9865,16 +9956,17 @@ compileThunks(MyThread* t, FixedAllocator* allocator)
 
     compileCall(t, &context, invokeNativeIndex);
 
-    a->popFrameAndUpdateStackAndReturn
-      (t->arch->alignFrameSize(1), TARGET_THREAD_NEWSTACK);
+    a->popFrameAndUpdateStackAndReturn(t->arch->alignFrameSize(1),
+                                       TARGET_THREAD_NEWSTACK);
 
     p->thunks.native.length = a->endBlock(false)->resolve(0, 0);
 
-    p->thunks.native.start = finish
-      (t, allocator, a, "native", p->thunks.native.length);
+    p->thunks.native.start
+        = finish(t, allocator, a, "native", p->thunks.native.length);
   }
 
-  { Context context(t);
+  {
+    Context context(t);
     avian::codegen::Assembler* a = context.assembler;
 
     a->saveFrame(TARGET_THREAD_STACK, TARGET_THREAD_IP);
@@ -9888,11 +9980,12 @@ compileThunks(MyThread* t, FixedAllocator* allocator)
 
     p->thunks.aioob.length = a->endBlock(false)->resolve(0, 0);
 
-    p->thunks.aioob.start = finish
-      (t, allocator, a, "aioob", p->thunks.aioob.length);
+    p->thunks.aioob.start
+        = finish(t, allocator, a, "aioob", p->thunks.aioob.length);
   }
 
-  { Context context(t);
+  {
+    Context context(t);
     avian::codegen::Assembler* a = context.assembler;
 
     a->saveFrame(TARGET_THREAD_STACK, TARGET_THREAD_IP);
@@ -9906,11 +9999,13 @@ compileThunks(MyThread* t, FixedAllocator* allocator)
 
     p->thunks.stackOverflow.length = a->endBlock(false)->resolve(0, 0);
 
-    p->thunks.stackOverflow.start = finish
-      (t, allocator, a, "stackOverflow", p->thunks.stackOverflow.length);
+    p->thunks.stackOverflow.start = finish(
+        t, allocator, a, "stackOverflow", p->thunks.stackOverflow.length);
   }
 
-  { { Context context(t);
+  {
+    {
+      Context context(t);
       avian::codegen::Assembler* a = context.assembler;
 
       a->saveFrame(TARGET_THREAD_STACK, TARGET_THREAD_IP);
@@ -9921,33 +10016,32 @@ compileThunks(MyThread* t, FixedAllocator* allocator)
 
       p->thunks.table.length = a->endBlock(false)->resolve(0, 0);
 
-      p->thunks.table.start = static_cast<uint8_t*>
-        (allocator->allocate
-         (p->thunks.table.length * ThunkCount, TargetBytesPerWord));
+      p->thunks.table.start = static_cast<uint8_t*>(allocator->allocate(
+          p->thunks.table.length * ThunkCount, TargetBytesPerWord));
     }
 
     uint8_t* start = p->thunks.table.start;
 
-#define THUNK(s) {                                                      \
-      Context context(t);                                               \
-      avian::codegen::Assembler* a = context.assembler;                                 \
-                                                                        \
-      a->saveFrame(TARGET_THREAD_STACK, TARGET_THREAD_IP);              \
-                                                                        \
-      p->thunks.table.frameSavedOffset = a->length();                   \
-                                                                        \
-      compileCall(t, &context, s##Index, false);                        \
-                                                                        \
-      expect(t, a->endBlock(false)->resolve(0, 0)                       \
-             <= p->thunks.table.length);                                \
-                                                                        \
-      a->setDestination(start);                                         \
-      a->write();                                                       \
-                                                                        \
-      logCompile(t, start, p->thunks.table.length, 0, #s, 0);           \
-                                                                        \
-      start += p->thunks.table.length;                                  \
-    }
+#define THUNK(s)                                                            \
+  {                                                                         \
+    Context context(t);                                                     \
+    avian::codegen::Assembler* a = context.assembler;                       \
+                                                                            \
+    a->saveFrame(TARGET_THREAD_STACK, TARGET_THREAD_IP);                    \
+                                                                            \
+    p->thunks.table.frameSavedOffset = a->length();                         \
+                                                                            \
+    compileCall(t, &context, s##Index, false);                              \
+                                                                            \
+    expect(t, a->endBlock(false)->resolve(0, 0) <= p->thunks.table.length); \
+                                                                            \
+    a->setDestination(start);                                               \
+    a->write();                                                             \
+                                                                            \
+    logCompile(t, start, p->thunks.table.length, 0, #s, 0);                 \
+                                                                            \
+    start += p->thunks.table.length;                                        \
+  }
 #include "thunks.cpp"
 #undef THUNK
   }
@@ -9958,74 +10052,63 @@ compileThunks(MyThread* t, FixedAllocator* allocator)
     uint8_t* imageBase = p->codeAllocator.memory.begin();
 
     image->thunks.default_ = thunkToThunk(p->thunks.default_, imageBase);
-    image->thunks.defaultVirtual = thunkToThunk
-      (p->thunks.defaultVirtual, imageBase);
+    image->thunks.defaultVirtual
+        = thunkToThunk(p->thunks.defaultVirtual, imageBase);
     image->thunks.native = thunkToThunk(p->thunks.native, imageBase);
     image->thunks.aioob = thunkToThunk(p->thunks.aioob, imageBase);
-    image->thunks.stackOverflow = thunkToThunk
-      (p->thunks.stackOverflow, imageBase);
+    image->thunks.stackOverflow
+        = thunkToThunk(p->thunks.stackOverflow, imageBase);
     image->thunks.table = thunkToThunk(p->thunks.table, imageBase);
   }
 }
 
-MyProcessor*
-processor(MyThread* t)
+MyProcessor* processor(MyThread* t)
 {
   return static_cast<MyProcessor*>(t->m->processor);
 }
 
-uintptr_t
-defaultThunk(MyThread* t)
+uintptr_t defaultThunk(MyThread* t)
 {
   return reinterpret_cast<uintptr_t>(processor(t)->thunks.default_.start);
 }
 
-uintptr_t
-bootDefaultThunk(MyThread* t)
+uintptr_t bootDefaultThunk(MyThread* t)
 {
   return reinterpret_cast<uintptr_t>(processor(t)->bootThunks.default_.start);
 }
 
-uintptr_t
-defaultVirtualThunk(MyThread* t)
+uintptr_t defaultVirtualThunk(MyThread* t)
 {
-  return reinterpret_cast<uintptr_t>
-    (processor(t)->thunks.defaultVirtual.start);
+  return reinterpret_cast<uintptr_t>(processor(t)->thunks.defaultVirtual.start);
 }
 
-uintptr_t
-nativeThunk(MyThread* t)
+uintptr_t nativeThunk(MyThread* t)
 {
   return reinterpret_cast<uintptr_t>(processor(t)->thunks.native.start);
 }
 
-uintptr_t
-bootNativeThunk(MyThread* t)
+uintptr_t bootNativeThunk(MyThread* t)
 {
   return reinterpret_cast<uintptr_t>(processor(t)->bootThunks.native.start);
 }
 
-uintptr_t
-aioobThunk(MyThread* t)
+uintptr_t aioobThunk(MyThread* t)
 {
   return reinterpret_cast<uintptr_t>(processor(t)->thunks.aioob.start);
 }
 
-uintptr_t
-stackOverflowThunk(MyThread* t)
+uintptr_t stackOverflowThunk(MyThread* t)
 {
   return reinterpret_cast<uintptr_t>(processor(t)->thunks.stackOverflow.start);
 }
 
-bool
-unresolved(MyThread* t, uintptr_t methodAddress)
+bool unresolved(MyThread* t, uintptr_t methodAddress)
 {
   return methodAddress == defaultThunk(t)
-    or methodAddress == bootDefaultThunk(t);
+         or methodAddress == bootDefaultThunk(t);
 }
 
-uintptr_t
-compileVirtualThunk(MyThread* t, unsigned index, unsigned* size)
+uintptr_t compileVirtualThunk(MyThread* t, unsigned index, unsigned* size)
 {
   Context context(t);
   avian::codegen::Assembler* a = context.assembler;
@@ -10033,19 +10116,21 @@ compileVirtualThunk(MyThread* t, unsigned index, unsigned* size)
   avian::codegen::ResolvedPromise indexPromise(index);
   lir::Constant indexConstant(&indexPromise);
   lir::Register indexRegister(t->arch->virtualCallIndex());
-  a->apply(lir::Move,
-           OperandInfo(TargetBytesPerWord, lir::ConstantOperand, &indexConstant),
-           OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &indexRegister));
+  a->apply(
+      lir::Move,
+      OperandInfo(TargetBytesPerWord, lir::ConstantOperand, &indexConstant),
+      OperandInfo(TargetBytesPerWord, lir::RegisterOperand, &indexRegister));
 
-  avian::codegen::ResolvedPromise defaultVirtualThunkPromise(defaultVirtualThunk(t));
+  avian::codegen::ResolvedPromise defaultVirtualThunkPromise(
+      defaultVirtualThunk(t));
   lir::Constant thunk(&defaultVirtualThunkPromise);
   a->apply(lir::Jump,
            OperandInfo(TargetBytesPerWord, lir::ConstantOperand, &thunk));
 
   *size = a->endBlock(false)->resolve(0, 0);
 
-  uint8_t* start = static_cast<uint8_t*>
-    (codeAllocator(t)->allocate(*size, TargetBytesPerWord));
+  uint8_t* start = static_cast<uint8_t*>(
+      codeAllocator(t)->allocate(*size, TargetBytesPerWord));
 
   a->setDestination(start);
   a->write();
@@ -10054,17 +10139,22 @@ compileVirtualThunk(MyThread* t, unsigned index, unsigned* size)
   const size_t virtualThunkBaseNameLength = strlen(virtualThunkBaseName);
   const size_t maxIntStringLength = 10;
 
-  THREAD_RUNTIME_ARRAY(t, char, virtualThunkName, virtualThunkBaseNameLength + maxIntStringLength);
+  THREAD_RUNTIME_ARRAY(t,
+                       char,
+                       virtualThunkName,
+                       virtualThunkBaseNameLength + maxIntStringLength);
 
-  sprintf(RUNTIME_ARRAY_BODY(virtualThunkName), "%s%d", virtualThunkBaseName, index);
+  sprintf(RUNTIME_ARRAY_BODY(virtualThunkName),
+          "%s%d",
+          virtualThunkBaseName,
+          index);
 
   logCompile(t, start, *size, 0, RUNTIME_ARRAY_BODY(virtualThunkName), 0);
 
   return reinterpret_cast<uintptr_t>(start);
 }
 
-uintptr_t
-virtualThunk(MyThread* t, unsigned index)
+uintptr_t virtualThunk(MyThread* t, unsigned index)
 {
   ACQUIRE(t, t->m->classLock);
 
@@ -10139,8 +10229,7 @@ void compile(MyThread* t,
       for (unsigned i = 0; i < ehTable->length(); ++i) {
         uint64_t handler = ehTable->body()[i];
         if (exceptionHandlerCatchType(handler)) {
-          resolveClassInPool
-            (t, clone, exceptionHandlerCatchType(handler) - 1);
+          resolveClassInPool(t, clone, exceptionHandlerCatchType(handler) - 1);
         }
       }
     }
@@ -10155,7 +10244,8 @@ void compile(MyThread* t,
   finish(t, allocator, &context);
 
   if (DebugMethodTree) {
-    fprintf(stderr, "insert method at %p\n",
+    fprintf(stderr,
+            "insert method at %p\n",
             reinterpret_cast<void*>(methodCompiled(t, clone)));
   }
 
@@ -10211,9 +10301,9 @@ avian::util::FixedAllocator* codeAllocator(MyThread* t)
   return &(processor(t)->codeAllocator);
 }
 
-} // namespace local
+}  // namespace local
 
-} // namespace
+}  // namespace
 
 namespace vm {
 
@@ -10223,7 +10313,8 @@ Processor* makeProcessor(System* system,
                          bool useNativeFeatures)
 {
   return new (allocator->allocate(sizeof(local::MyProcessor)))
-    local::MyProcessor(system, allocator, crashDumpDirectory, useNativeFeatures);
+      local::MyProcessor(
+          system, allocator, crashDumpDirectory, useNativeFeatures);
 }
 
-} // namespace vm
+}  // namespace vm
diff --git a/src/embed.cpp b/src/embed.cpp
index 804f505766..05ea91a844 100644
--- a/src/embed.cpp
+++ b/src/embed.cpp
@@ -18,105 +18,118 @@
 #include "avian/embed.h"
 
 #ifdef __x86_64__
-#  define BINARY_LOADER(x) _binary_loader_##x
+#define BINARY_LOADER(x) _binary_loader_##x
 #else
-#  define BINARY_LOADER(x) binary_loader_##x
+#define BINARY_LOADER(x) binary_loader_##x
 #endif
 
 extern "C" const uint8_t BINARY_LOADER(start)[];
 extern "C" const uint8_t BINARY_LOADER(end)[];
 
-__declspec(noreturn)
-void printUsage(const wchar_t* executableName)
+__declspec(noreturn) void printUsage(const wchar_t* executableName)
 {
-	wprintf(L"Usage: %s destination.exe classes.jar package.Main\n", executableName);
-	exit(0);
+  wprintf(L"Usage: %s destination.exe classes.jar package.Main\n",
+          executableName);
+  exit(0);
 }
 
 void writeDestinationFile(const wchar_t* filename)
 {
-	if(FILE* file = _wfopen(filename, L"wb"))
-	{
-		size_t count = BINARY_LOADER(end) - BINARY_LOADER(start);
-		if(count == fwrite(BINARY_LOADER(start), sizeof(BINARY_LOADER(start)[0]), count, file))
-		{
-			fclose(file);
-			return;
-		}
-	}
-	
-	fprintf(stderr, "Unable to write to destination file\n");
-	exit(EXIT_FAILURE);
+  if (FILE* file = _wfopen(filename, L"wb")) {
+    size_t count = BINARY_LOADER(end) - BINARY_LOADER(start);
+    if (count == fwrite(BINARY_LOADER(start),
+                        sizeof(BINARY_LOADER(start)[0]),
+                        count,
+                        file)) {
+      fclose(file);
+      return;
+    }
+  }
+
+  fprintf(stderr, "Unable to write to destination file\n");
+  exit(EXIT_FAILURE);
 }
 
 void readFile(std::vector<char>* jarFile, const wchar_t* fileName)
 {
-	if(FILE* file = _wfopen(fileName, L"rb"))
-	{
-		fseek(file, 0, SEEK_END);
-		jarFile->resize(ftell(file));
-		fseek(file, 0, SEEK_SET);
-		fread(&jarFile->at(0), 1, jarFile->size(), file);
-		fclose(file);
-	}
+  if (FILE* file = _wfopen(fileName, L"rb")) {
+    fseek(file, 0, SEEK_END);
+    jarFile->resize(ftell(file));
+    fseek(file, 0, SEEK_SET);
+    fread(&jarFile->at(0), 1, jarFile->size(), file);
+    fclose(file);
+  }
 }
 
-bool mkStringSection(std::vector<wchar_t>* stringSection, const std::vector<std::wstring>& strings, int first, int last)
+bool mkStringSection(std::vector<wchar_t>* stringSection,
+                     const std::vector<std::wstring>& strings,
+                     int first,
+                     int last)
 {
-	stringSection->clear();
-	for(int i = first; i <= last; ++i)
-	{
-		const std::wstring& s = strings.at(i);
-		stringSection->push_back(s.size());
-		stringSection->insert(stringSection->end(), s.begin(), s.end());
-	}
+  stringSection->clear();
+  for (int i = first; i <= last; ++i) {
+    const std::wstring& s = strings.at(i);
+    stringSection->push_back(s.size());
+    stringSection->insert(stringSection->end(), s.begin(), s.end());
+  }
 
-	// pad to 16 entries
-	for(int i = last - first; i < 15; ++i)
-		stringSection->push_back(0);
+  // pad to 16 entries
+  for (int i = last - first; i < 15; ++i)
+    stringSection->push_back(0);
 
-	return stringSection->size() > 16;
+  return stringSection->size() > 16;
 }
 
-void writeStringResources(HANDLE hDest, const std::vector<std::wstring>& strings)
+void writeStringResources(HANDLE hDest,
+                          const std::vector<std::wstring>& strings)
 {
-	for(unsigned i = 0; i < strings.size(); i += 16)
-	{
-		std::vector<wchar_t> stringSection;
+  for (unsigned i = 0; i < strings.size(); i += 16) {
+    std::vector<wchar_t> stringSection;
 
-		if(mkStringSection(&stringSection, strings, i, std::min<int>(i + 15, strings.size() - 1)))
-                  UpdateResourceW(hDest, reinterpret_cast<LPCWSTR>(RT_STRING), reinterpret_cast<LPCWSTR>(MAKEINTRESOURCE((i >> 4) + 1)), LANG_NEUTRAL, &stringSection.at(0), sizeof(wchar_t) * stringSection.size());
-	}
+    if (mkStringSection(&stringSection,
+                        strings,
+                        i,
+                        std::min<int>(i + 15, strings.size() - 1)))
+      UpdateResourceW(hDest,
+                      reinterpret_cast<LPCWSTR>(RT_STRING),
+                      reinterpret_cast<LPCWSTR>(MAKEINTRESOURCE((i >> 4) + 1)),
+                      LANG_NEUTRAL,
+                      &stringSection.at(0),
+                      sizeof(wchar_t) * stringSection.size());
+  }
 }
 
 int wmain(int argc, wchar_t* argv[])
 {
-	if(argc != 4)
-		printUsage(argv[0]);
+  if (argc != 4)
+    printUsage(argv[0]);
 
-	const wchar_t* destinationName = argv[1];
-	const wchar_t* classesName = argv[2];
-	const wchar_t* mainClassName = argv[3];
-	
-	writeDestinationFile(destinationName);
-	
-	if(HANDLE hDest = BeginUpdateResourceW(destinationName, TRUE))
-	{
-		std::vector<std::wstring> strings;
-		strings.resize(RESID_MAIN_CLASS + 1);
-		strings.at(RESID_MAIN_CLASS) = mainClassName;
-		
-		writeStringResources(hDest, strings);
-		
-		std::vector<char> jarFile;
-		readFile(&jarFile, classesName);
-		UpdateResourceW(hDest, reinterpret_cast<LPCWSTR>(RT_RCDATA), RESID_BOOT_JAR, LANG_NEUTRAL, &jarFile.at(0), jarFile.size());
-		
-		EndUpdateResource(hDest, FALSE);
-	}
-	
+  const wchar_t* destinationName = argv[1];
+  const wchar_t* classesName = argv[2];
+  const wchar_t* mainClassName = argv[3];
 
-	return 0;
+  writeDestinationFile(destinationName);
+
+  if (HANDLE hDest = BeginUpdateResourceW(destinationName, TRUE)) {
+    std::vector<std::wstring> strings;
+    strings.resize(RESID_MAIN_CLASS + 1);
+    strings.at(RESID_MAIN_CLASS) = mainClassName;
+
+    writeStringResources(hDest, strings);
+
+    std::vector<char> jarFile;
+    readFile(&jarFile, classesName);
+    UpdateResourceW(hDest,
+                    reinterpret_cast<LPCWSTR>(RT_RCDATA),
+                    RESID_BOOT_JAR,
+                    LANG_NEUTRAL,
+                    &jarFile.at(0),
+                    jarFile.size());
+
+    EndUpdateResource(hDest, FALSE);
+  }
+
+  return 0;
 }
 
 #ifndef _MSC_VER
@@ -125,9 +138,9 @@ extern "C" void __wgetmainargs(int*, wchar_t***, wchar_t***, int, int*);
 
 int main()
 {
-	wchar_t **enpv, **argv;
-	int argc, si = 0;
-	__wgetmainargs(&argc, &argv, &enpv, _CRT_glob, &si);
-	return wmain(argc, argv);
+  wchar_t** enpv, **argv;
+  int argc, si = 0;
+  __wgetmainargs(&argc, &argv, &enpv, _CRT_glob, &si);
+  return wmain(argc, argv);
 }
 #endif
diff --git a/src/embedded-loader.cpp b/src/embedded-loader.cpp
index 6c6bf59b4a..59fd529b66 100644
--- a/src/embedded-loader.cpp
+++ b/src/embedded-loader.cpp
@@ -17,40 +17,39 @@
 #include "jni.h"
 
 extern "C" {
-  // since we aren't linking against libstdc++, we must implement this   
-  // ourselves:
-  void __cxa_pure_virtual(void) { abort(); }
+// since we aren't linking against libstdc++, we must implement this
+// ourselves:
+void __cxa_pure_virtual(void)
+{
+  abort();
+}
 
-  AVIAN_EXPORT const uint8_t*
-  bootJar(unsigned* size)
-  {
-    if(HRSRC hResInfo = FindResourceW(NULL, RESID_BOOT_JAR, reinterpret_cast<LPCWSTR>(RT_RCDATA)))
-    {
-      if(HGLOBAL hRes = LoadResource(NULL, hResInfo))
-      {
-        *size = SizeofResource(NULL, hResInfo);
-        return (const uint8_t*)LockResource(hRes);
-      }
+AVIAN_EXPORT const uint8_t* bootJar(unsigned* size)
+{
+  if (HRSRC hResInfo = FindResourceW(
+          NULL, RESID_BOOT_JAR, reinterpret_cast<LPCWSTR>(RT_RCDATA))) {
+    if (HGLOBAL hRes = LoadResource(NULL, hResInfo)) {
+      *size = SizeofResource(NULL, hResInfo);
+      return (const uint8_t*)LockResource(hRes);
     }
-
-	fprintf(stderr, "boot.jar resource not found\n");
-
-    *size = 0;
-    return NULL;
   }
-} // extern "C"
+
+  fprintf(stderr, "boot.jar resource not found\n");
+
+  *size = 0;
+  return NULL;
+}
+}  // extern "C"
 
 static void getMainClass(char* pName, int maxLen)
 {
-  if(0 == LoadString(NULL, RESID_MAIN_CLASS, pName, maxLen))
-  {
+  if (0 == LoadString(NULL, RESID_MAIN_CLASS, pName, maxLen)) {
     fprintf(stderr, "Main class not specified\n");
     strcpy(pName, "Main");
   }
 }
 
-int
-main(int ac, const char** av)
+int main(int ac, const char** av)
 {
   JavaVMInitArgs vmArgs;
   vmArgs.version = JNI_VERSION_1_2;
@@ -72,24 +71,28 @@ main(int ac, const char** av)
 
   jclass c = e->FindClass(mainClass);
   if (not e->ExceptionCheck()) {
-	jmethodID m = e->GetStaticMethodID(c, "main", "([Ljava/lang/String;)V");
-	if (not e->ExceptionCheck()) {
-	  jclass stringClass = e->FindClass("java/lang/String");
-	  if (not e->ExceptionCheck()) {
-		jobjectArray a = e->NewObjectArray(ac-1, stringClass, 0);
-		if (not e->ExceptionCheck()) {
-		  for (int i = 1; i < ac; ++i) {
-			e->SetObjectArrayElement(a, i-1, e->NewStringUTF(av[i]));
-		  }
-		  
-		  e->CallStaticVoidMethod(c, m, a);
-		} else fprintf(stderr, "Couldn't create array\n");
-	  } else fprintf(stderr, "java.lang.String not found\n");
-	} else fprintf(stderr, "main method not found\n");
-  } else fprintf(stderr, "Main class not found\n");
+    jmethodID m = e->GetStaticMethodID(c, "main", "([Ljava/lang/String;)V");
+    if (not e->ExceptionCheck()) {
+      jclass stringClass = e->FindClass("java/lang/String");
+      if (not e->ExceptionCheck()) {
+        jobjectArray a = e->NewObjectArray(ac - 1, stringClass, 0);
+        if (not e->ExceptionCheck()) {
+          for (int i = 1; i < ac; ++i) {
+            e->SetObjectArrayElement(a, i - 1, e->NewStringUTF(av[i]));
+          }
+
+          e->CallStaticVoidMethod(c, m, a);
+        } else
+          fprintf(stderr, "Couldn't create array\n");
+      } else
+        fprintf(stderr, "java.lang.String not found\n");
+    } else
+      fprintf(stderr, "main method not found\n");
+  } else
+    fprintf(stderr, "Main class not found\n");
 
   int exitCode = 0;
-  if(e->ExceptionCheck()) {
+  if (e->ExceptionCheck()) {
     exitCode = -1;
     e->ExceptionDescribe();
     e->ExceptionClear();
diff --git a/src/finder.cpp b/src/finder.cpp
index a1a6a3b979..f211928663 100644
--- a/src/finder.cpp
+++ b/src/finder.cpp
@@ -35,11 +35,14 @@ class Element {
     virtual void dispose() = 0;
   };
 
-  Element(): next(0) { }
+  Element() : next(0)
+  {
+  }
 
   virtual Iterator* iterator() = 0;
   virtual System::Region* find(const char* name) = 0;
-  virtual System::FileType stat(const char* name, unsigned* length,
+  virtual System::FileType stat(const char* name,
+                                unsigned* length,
                                 bool tryDirectory) = 0;
   virtual const char* urlPrefix() = 0;
   virtual const char* sourceUrl() = 0;
@@ -48,20 +51,26 @@ class Element {
   Element* next;
 };
 
-class DirectoryElement: public Element {
+class DirectoryElement : public Element {
  public:
-  class Iterator: public Element::Iterator {
+  class Iterator : public Element::Iterator {
    public:
-    Iterator(System* s, Allocator* allocator, const char* name, unsigned skip):
-      s(s), allocator(allocator), name(name), skip(skip), directory(0),
-      last(0), it(0)
+    Iterator(System* s, Allocator* allocator, const char* name, unsigned skip)
+        : s(s),
+          allocator(allocator),
+          name(name),
+          skip(skip),
+          directory(0),
+          last(0),
+          it(0)
     {
       if (not s->success(s->open(&directory, name))) {
         directory = 0;
       }
     }
 
-    virtual const char* next(unsigned* size) {
+    virtual const char* next(unsigned* size)
+    {
       if (it) {
         const char* v = it->next(size);
         if (v) {
@@ -83,7 +92,7 @@ class DirectoryElement: public Element {
             unsigned length;
             if (s->stat(last, &length) == System::TypeDirectory) {
               it = new (allocator->allocate(sizeof(Iterator)))
-                Iterator(s, allocator, last, skip);
+                  Iterator(s, allocator, last, skip);
               it->name = last;
             }
             const char* result = last + skip;
@@ -96,7 +105,8 @@ class DirectoryElement: public Element {
       return 0;
     }
 
-    virtual void dispose() {
+    virtual void dispose()
+    {
       directory->dispose();
       allocator->free(this, sizeof(*this));
     }
@@ -110,21 +120,24 @@ class DirectoryElement: public Element {
     Iterator* it;
   };
 
-  DirectoryElement(System* s, Allocator* allocator, const char* name):
-    s(s),
-    allocator(allocator),
-    originalName(name),
-    name(s->toAbsolutePath(allocator, name)),
-    urlPrefix_(append(allocator, "file:", this->name, "/")),
-    sourceUrl_(append(allocator, "file:", this->name))
-  { }
-
-  virtual Element::Iterator* iterator() {
-    return new (allocator->allocate(sizeof(Iterator)))
-      Iterator(s, allocator, name, strlen(name) + 1);
+  DirectoryElement(System* s, Allocator* allocator, const char* name)
+      : s(s),
+        allocator(allocator),
+        originalName(name),
+        name(s->toAbsolutePath(allocator, name)),
+        urlPrefix_(append(allocator, "file:", this->name, "/")),
+        sourceUrl_(append(allocator, "file:", this->name))
+  {
   }
 
-  virtual System::Region* find(const char* name) {
+  virtual Element::Iterator* iterator()
+  {
+    return new (allocator->allocate(sizeof(Iterator)))
+        Iterator(s, allocator, name, strlen(name) + 1);
+  }
+
+  virtual System::Region* find(const char* name)
+  {
     const char* file = append(allocator, this->name, "/", name);
     System::Region* region;
     System::Status status = s->map(&region, file);
@@ -143,7 +156,8 @@ class DirectoryElement: public Element {
     }
   }
 
-  virtual System::FileType stat(const char* name, unsigned* length, bool)  {
+  virtual System::FileType stat(const char* name, unsigned* length, bool)
+  {
     const char* file = append(allocator, this->name, "/", name);
     System::FileType type = s->stat(file, length);
     if (DebugStat) {
@@ -153,15 +167,18 @@ class DirectoryElement: public Element {
     return type;
   }
 
-  virtual const char* urlPrefix() {
+  virtual const char* urlPrefix()
+  {
     return urlPrefix_;
   }
 
-  virtual const char* sourceUrl() {
+  virtual const char* sourceUrl()
+  {
     return sourceUrl_;
   }
 
-  virtual void dispose() {
+  virtual void dispose()
+  {
     allocator->free(originalName, strlen(originalName) + 1);
     allocator->free(name, strlen(name) + 1);
     allocator->free(urlPrefix_, strlen(urlPrefix_) + 1);
@@ -177,26 +194,33 @@ class DirectoryElement: public Element {
   const char* sourceUrl_;
 };
 
-class PointerRegion: public System::Region {
+class PointerRegion : public System::Region {
  public:
-  PointerRegion(System* s, Allocator* allocator, const uint8_t* start,
-                size_t length, bool freePointer = false):
-    s(s),
-    allocator(allocator),
-    start_(start),
-    length_(length),
-    freePointer(freePointer)
-  { }
+  PointerRegion(System* s,
+                Allocator* allocator,
+                const uint8_t* start,
+                size_t length,
+                bool freePointer = false)
+      : s(s),
+        allocator(allocator),
+        start_(start),
+        length_(length),
+        freePointer(freePointer)
+  {
+  }
 
-  virtual const uint8_t* start() {
+  virtual const uint8_t* start()
+  {
     return start_;
   }
 
-  virtual size_t length() {
+  virtual size_t length()
+  {
     return length_;
   }
 
-  virtual void dispose() {
+  virtual void dispose()
+  {
     if (freePointer) {
       allocator->free(start_, length_);
     }
@@ -210,23 +234,25 @@ class PointerRegion: public System::Region {
   bool freePointer;
 };
 
-class DataRegion: public System::Region {
+class DataRegion : public System::Region {
  public:
-  DataRegion(System* s, Allocator* allocator, size_t length):
-    s(s),
-    allocator(allocator),
-    length_(length)
-  { }
+  DataRegion(System* s, Allocator* allocator, size_t length)
+      : s(s), allocator(allocator), length_(length)
+  {
+  }
 
-  virtual const uint8_t* start() {
+  virtual const uint8_t* start()
+  {
     return data;
   }
 
-  virtual size_t length() {
+  virtual size_t length()
+  {
     return length_;
   }
 
-  virtual void dispose() {
+  virtual void dispose()
+  {
     allocator->free(this, sizeof(*this) + length_);
   }
 
@@ -238,39 +264,37 @@ class DataRegion: public System::Region {
 
 class JarIndex {
  public:
-  enum CompressionMethod {
-    Stored = 0,
-    Deflated = 8
-  };
+  enum CompressionMethod { Stored = 0, Deflated = 8 };
 
   class Entry {
-  public:
-    Entry(uint32_t hash, const uint8_t* entry):
-      hash(hash),
-      entry(entry) {}
+   public:
+    Entry(uint32_t hash, const uint8_t* entry) : hash(hash), entry(entry)
+    {
+    }
 
     uint32_t hash;
     const uint8_t* entry;
   };
 
-  JarIndex(System* s, Allocator* allocator, unsigned capacity):
-    s(s),
-    allocator(allocator),
-    capacity(capacity),
-    position(0),
-    nodes(static_cast<List<Entry>*>(allocator->allocate(sizeof(List<Entry>) * capacity)))
+  JarIndex(System* s, Allocator* allocator, unsigned capacity)
+      : s(s),
+        allocator(allocator),
+        capacity(capacity),
+        position(0),
+        nodes(static_cast<List<Entry>*>(
+            allocator->allocate(sizeof(List<Entry>) * capacity)))
   {
     memset(table, 0, sizeof(List<Entry>*) * capacity);
   }
 
-  static JarIndex* make(System* s, Allocator* allocator, unsigned capacity) {
-    return new
-      (allocator->allocate(sizeof(JarIndex) + (sizeof(List<Entry>*) * capacity)))
-      JarIndex(s, allocator, capacity);
+  static JarIndex* make(System* s, Allocator* allocator, unsigned capacity)
+  {
+    return new (allocator->allocate(sizeof(JarIndex)
+                                    + (sizeof(List<Entry>*) * capacity)))
+        JarIndex(s, allocator, capacity);
   }
-  
-  static JarIndex* open(System* s, Allocator* allocator,
-                        System::Region* region)
+
+  static JarIndex* open(System* s, Allocator* allocator, System::Region* region)
   {
     JarIndex* index = make(s, allocator, 32);
 
@@ -300,7 +324,8 @@ class JarIndex {
     return index;
   }
 
-  JarIndex* add(const Entry& entry) {
+  JarIndex* add(const Entry& entry)
+  {
     if (position < capacity) {
       unsigned i = entry.hash & (capacity - 1);
       table[i] = new (nodes + (position++)) List<Entry>(entry, table[i]);
@@ -316,7 +341,8 @@ class JarIndex {
     }
   }
 
-  List<Entry>* findNode(const char* name) {
+  List<Entry>* findNode(const char* name)
+  {
     unsigned length = strlen(name);
     unsigned i = hash(name) & (capacity - 1);
     for (List<Entry>* n = table[i]; n; n = n->next) {
@@ -328,26 +354,30 @@ class JarIndex {
     return 0;
   }
 
-  System::Region* find(const char* name, const uint8_t* start) {
+  System::Region* find(const char* name, const uint8_t* start)
+  {
     List<Entry>* n = findNode(name);
     if (n) {
       const uint8_t* p = n->item.entry;
       switch (compressionMethod(p)) {
       case Stored: {
         return new (allocator->allocate(sizeof(PointerRegion)))
-          PointerRegion(s, allocator, fileData(start + localHeaderOffset(p)),
-          compressedSize(p));
+            PointerRegion(s,
+                          allocator,
+                          fileData(start + localHeaderOffset(p)),
+                          compressedSize(p));
       } break;
 
       case Deflated: {
-        DataRegion* region = new
-          (allocator->allocate(sizeof(DataRegion) + uncompressedSize(p)))
-          DataRegion(s, allocator, uncompressedSize(p));
-          
-        z_stream zStream; memset(&zStream, 0, sizeof(z_stream));
+        DataRegion* region = new (
+            allocator->allocate(sizeof(DataRegion) + uncompressedSize(p)))
+            DataRegion(s, allocator, uncompressedSize(p));
 
-        zStream.next_in = const_cast<uint8_t*>(fileData(start +
-              localHeaderOffset(p)));
+        z_stream zStream;
+        memset(&zStream, 0, sizeof(z_stream));
+
+        zStream.next_in
+            = const_cast<uint8_t*>(fileData(start + localHeaderOffset(p)));
         zStream.avail_in = compressedSize(p);
         zStream.next_out = region->data;
         zStream.avail_out = region->length();
@@ -400,7 +430,8 @@ class JarIndex {
     }
   }
 
-  void dispose() {
+  void dispose()
+  {
     allocator->free(nodes, sizeof(List<Entry>) * capacity);
     allocator->free(this, sizeof(*this) + (sizeof(List<Entry>*) * capacity));
   }
@@ -409,20 +440,22 @@ class JarIndex {
   Allocator* allocator;
   unsigned capacity;
   unsigned position;
-  
+
   List<Entry>* nodes;
   List<Entry>* table[0];
 };
 
-class JarElement: public Element {
+class JarElement : public Element {
  public:
-  class Iterator: public Element::Iterator {
+  class Iterator : public Element::Iterator {
    public:
-    Iterator(System* s, Allocator* allocator, JarIndex* index):
-      s(s), allocator(allocator), index(index), position(0)
-    { }
+    Iterator(System* s, Allocator* allocator, JarIndex* index)
+        : s(s), allocator(allocator), index(index), position(0)
+    {
+    }
 
-    virtual const char* next(unsigned* size) {
+    virtual const char* next(unsigned* size)
+    {
       if (position < index->position) {
         List<JarIndex::Entry>* n = index->nodes + (position++);
         *size = fileNameLength(n->item.entry);
@@ -432,7 +465,8 @@ class JarElement: public Element {
       }
     }
 
-    virtual void dispose() {
+    virtual void dispose()
+    {
       allocator->free(this, sizeof(*this));
     }
 
@@ -442,41 +476,49 @@ class JarElement: public Element {
     unsigned position;
   };
 
-  JarElement(System* s, Allocator* allocator, const char* name,
-             bool canonicalizePath = true):
-    s(s),
-    allocator(allocator),
-    originalName(name),
-    name(name and canonicalizePath
-         ? s->toAbsolutePath(allocator, name) : name),
-    urlPrefix_(this->name
-               ? append(allocator, "jar:file:", this->name, "!/") : 0),
-    sourceUrl_(this->name
-               ? append(allocator, "file:", this->name) : 0),
-    region(0), index(0)
-  { }
+  JarElement(System* s,
+             Allocator* allocator,
+             const char* name,
+             bool canonicalizePath = true)
+      : s(s),
+        allocator(allocator),
+        originalName(name),
+        name(name and canonicalizePath ? s->toAbsolutePath(allocator, name)
+                                       : name),
+        urlPrefix_(this->name ? append(allocator, "jar:file:", this->name, "!/")
+                              : 0),
+        sourceUrl_(this->name ? append(allocator, "file:", this->name) : 0),
+        region(0),
+        index(0)
+  {
+  }
 
-  JarElement(System* s, Allocator* allocator, const uint8_t* jarData,
-             unsigned jarLength):
-    s(s),
-    allocator(allocator),
-    originalName(0),
-    name(0),
-    urlPrefix_(name ? append(allocator, "jar:file:", name, "!/") : 0),
-    sourceUrl_(name ? append(allocator, "file:", name) : 0),
-    region(new (allocator->allocate(sizeof(PointerRegion)))
-           PointerRegion(s, allocator, jarData, jarLength)),
-    index(JarIndex::open(s, allocator, region))
-  { }
+  JarElement(System* s,
+             Allocator* allocator,
+             const uint8_t* jarData,
+             unsigned jarLength)
+      : s(s),
+        allocator(allocator),
+        originalName(0),
+        name(0),
+        urlPrefix_(name ? append(allocator, "jar:file:", name, "!/") : 0),
+        sourceUrl_(name ? append(allocator, "file:", name) : 0),
+        region(new (allocator->allocate(sizeof(PointerRegion)))
+               PointerRegion(s, allocator, jarData, jarLength)),
+        index(JarIndex::open(s, allocator, region))
+  {
+  }
 
-  virtual Element::Iterator* iterator() {
+  virtual Element::Iterator* iterator()
+  {
     init();
 
     return new (allocator->allocate(sizeof(Iterator)))
-      Iterator(s, allocator, index);
+        Iterator(s, allocator, index);
   }
 
-  virtual void init() {
+  virtual void init()
+  {
     if (index == 0) {
       System::Region* r;
       if (s->success(s->map(&r, name))) {
@@ -486,10 +528,12 @@ class JarElement: public Element {
     }
   }
 
-  virtual System::Region* find(const char* name) {
+  virtual System::Region* find(const char* name)
+  {
     init();
 
-    while (*name == '/') name++;
+    while (*name == '/')
+      name++;
 
     System::Region* r = (index ? index->find(name, region->start()) : 0);
     if (DebugFind) {
@@ -502,34 +546,40 @@ class JarElement: public Element {
     return r;
   }
 
-  virtual System::FileType stat(const char* name, unsigned* length,
+  virtual System::FileType stat(const char* name,
+                                unsigned* length,
                                 bool tryDirectory)
   {
     init();
 
-    while (*name == '/') name++;
+    while (*name == '/')
+      name++;
 
     System::FileType type = (index ? index->stat(name, length, tryDirectory)
-                             : System::TypeDoesNotExist);
+                                   : System::TypeDoesNotExist);
     if (DebugStat) {
       fprintf(stderr, "stat %s in %s: %d\n", name, this->name, type);
     }
     return type;
   }
 
-  virtual const char* urlPrefix() {
+  virtual const char* urlPrefix()
+  {
     return urlPrefix_;
   }
 
-  virtual const char* sourceUrl() {
+  virtual const char* sourceUrl()
+  {
     return sourceUrl_;
   }
 
-  virtual void dispose() {
+  virtual void dispose()
+  {
     dispose(sizeof(*this));
   }
 
-  virtual void dispose(unsigned size) {
+  virtual void dispose(unsigned size)
+  {
     if (name) {
       if (originalName != name) {
         allocator->free(originalName, strlen(originalName) + 1);
@@ -557,15 +607,19 @@ class JarElement: public Element {
   JarIndex* index;
 };
 
-class BuiltinElement: public JarElement {
+class BuiltinElement : public JarElement {
  public:
-  BuiltinElement(System* s, Allocator* allocator, const char* name,
-                 const char* libraryName):
-    JarElement(s, allocator, name, false),
-    libraryName(libraryName ? copy(allocator, libraryName) : 0)
-  { }
+  BuiltinElement(System* s,
+                 Allocator* allocator,
+                 const char* name,
+                 const char* libraryName)
+      : JarElement(s, allocator, name, false),
+        libraryName(libraryName ? copy(allocator, libraryName) : 0)
+  {
+  }
 
-  virtual void init() {
+  virtual void init()
+  {
     if (index == 0) {
       if (s->success(s->load(&library, libraryName))) {
         bool lzma = strncmp("lzma.", name, 5) == 0;
@@ -593,29 +647,31 @@ class BuiltinElement: public JarElement {
               freePointer = false;
             }
             region = new (allocator->allocate(sizeof(PointerRegion)))
-              PointerRegion(s, allocator, data, size, freePointer);
+                PointerRegion(s, allocator, data, size, freePointer);
             index = JarIndex::open(s, allocator, region);
           } else if (DebugFind) {
-            fprintf(stderr, "%s in %s returned null\n", symbolName,
-                    libraryName);
+            fprintf(
+                stderr, "%s in %s returned null\n", symbolName, libraryName);
           }
         } else if (DebugFind) {
-          fprintf(stderr, "unable to find %s in %s\n", symbolName,
-                  libraryName);
+          fprintf(stderr, "unable to find %s in %s\n", symbolName, libraryName);
         }
       }
     }
   }
 
-  virtual const char* urlPrefix() {
+  virtual const char* urlPrefix()
+  {
     return "avianvmresource:";
   }
 
-  virtual const char* sourceUrl() {
+  virtual const char* sourceUrl()
+  {
     return 0;
   }
 
-  virtual void dispose() {
+  virtual void dispose()
+  {
     library->disposeAll();
     if (libraryName) {
       allocator->free(libraryName, strlen(libraryName) + 1);
@@ -627,8 +683,7 @@ class BuiltinElement: public JarElement {
   const char* libraryName;
 };
 
-void
-add(Element** first, Element** last, Element* e)
+void add(Element** first, Element** last, Element* e)
 {
   if (*last) {
     (*last)->next = e;
@@ -638,8 +693,7 @@ add(Element** first, Element** last, Element* e)
   *last = e;
 }
 
-unsigned
-baseName(const char* name, char fileSeparator)
+unsigned baseName(const char* name, char fileSeparator)
 {
   const char* p = name;
   const char* last = 0;
@@ -653,14 +707,23 @@ baseName(const char* name, char fileSeparator)
   return last ? (last + 1) - name : 0;
 }
 
-void
-add(System* s, Element** first, Element** last, Allocator* allocator,
-    const char* name, unsigned nameLength, const char* bootLibrary);
+void add(System* s,
+         Element** first,
+         Element** last,
+         Allocator* allocator,
+         const char* name,
+         unsigned nameLength,
+         const char* bootLibrary);
 
-void
-addTokens(System* s, Element** first, Element** last, Allocator* allocator,
-          const char* jarName, unsigned jarNameBase, const char* tokens,
-          unsigned tokensLength, const char* bootLibrary)
+void addTokens(System* s,
+               Element** first,
+               Element** last,
+               Allocator* allocator,
+               const char* jarName,
+               unsigned jarNameBase,
+               const char* tokens,
+               unsigned tokensLength,
+               const char* bootLibrary)
 {
   for (Tokenizer t(String(tokens, tokensLength), ' '); t.hasMore();) {
     String token(t.next());
@@ -669,31 +732,39 @@ addTokens(System* s, Element** first, Element** last, Allocator* allocator,
     memcpy(RUNTIME_ARRAY_BODY(n), jarName, jarNameBase);
     memcpy(RUNTIME_ARRAY_BODY(n) + jarNameBase, token.text, token.length);
     RUNTIME_ARRAY_BODY(n)[jarNameBase + token.length] = 0;
-          
-    add(s, first, last, allocator, RUNTIME_ARRAY_BODY(n),
-        jarNameBase + token.length, bootLibrary);
+
+    add(s,
+        first,
+        last,
+        allocator,
+        RUNTIME_ARRAY_BODY(n),
+        jarNameBase + token.length,
+        bootLibrary);
   }
 }
 
-bool
-continuationLine(const uint8_t* base, unsigned total, unsigned* start,
-                 unsigned* length)
+bool continuationLine(const uint8_t* base,
+                      unsigned total,
+                      unsigned* start,
+                      unsigned* length)
 {
-  return readLine(base, total, start, length)
-    and *length > 0
-    and base[*start] == ' ';
+  return readLine(base, total, start, length) and *length > 0
+         and base[*start] == ' ';
 }
 
-void
-addJar(System* s, Element** first, Element** last, Allocator* allocator,
-       const char* name, const char* bootLibrary)
+void addJar(System* s,
+            Element** first,
+            Element** last,
+            Allocator* allocator,
+            const char* name,
+            const char* bootLibrary)
 {
   if (DebugFind) {
     fprintf(stderr, "add jar %s\n", name);
   }
 
   JarElement* e = new (allocator->allocate(sizeof(JarElement)))
-    JarElement(s, allocator, name);
+      JarElement(s, allocator, name);
 
   unsigned nameBase = baseName(name, s->fileSeparator());
 
@@ -708,52 +779,65 @@ addJar(System* s, Element** first, Element** last, Allocator* allocator,
 
       const unsigned PrefixLength = 12;
       if (length > PrefixLength
-          and strncmp("Class-Path: ", reinterpret_cast<const char*>
-                      (region->start() + start), PrefixLength) == 0)
-      {
-        { unsigned nextStart = start + length;
+          and strncmp("Class-Path: ",
+                      reinterpret_cast<const char*>(region->start() + start),
+                      PrefixLength) == 0) {
+        {
+          unsigned nextStart = start + length;
           unsigned nextLength;
-          while (continuationLine
-                 (region->start(), region->length(), &nextStart, &nextLength))
-          {
+          while (continuationLine(
+              region->start(), region->length(), &nextStart, &nextLength)) {
             multilineTotal += nextLength;
             nextStart += nextLength;
           }
         }
 
-        const char* line = reinterpret_cast<const char*>
-          (region->start() + start + PrefixLength);
+        const char* line = reinterpret_cast<const char*>(region->start() + start
+                                                         + PrefixLength);
 
         unsigned lineLength = length - PrefixLength;
 
         if (multilineTotal) {
-          RUNTIME_ARRAY
-            (char, n, (length - PrefixLength) + multilineTotal + 1);
+          RUNTIME_ARRAY(char, n, (length - PrefixLength) + multilineTotal + 1);
 
           memcpy(RUNTIME_ARRAY_BODY(n), line, lineLength);
 
           unsigned offset = lineLength;
-          { unsigned nextStart = start + length;
+          {
+            unsigned nextStart = start + length;
             unsigned nextLength;
-            while (continuationLine
-                   (region->start(), region->length(), &nextStart,
-                    &nextLength))
-            {
+            while (continuationLine(
+                region->start(), region->length(), &nextStart, &nextLength)) {
               unsigned continuationLength = nextLength - 1;
 
               memcpy(RUNTIME_ARRAY_BODY(n) + offset,
-                     region->start() + nextStart + 1, continuationLength);
-            
+                     region->start() + nextStart + 1,
+                     continuationLength);
+
               offset += continuationLength;
               nextStart += nextLength;
             }
           }
 
-          addTokens(s, first, last, allocator, name, nameBase,
-                    RUNTIME_ARRAY_BODY(n), offset, bootLibrary);
+          addTokens(s,
+                    first,
+                    last,
+                    allocator,
+                    name,
+                    nameBase,
+                    RUNTIME_ARRAY_BODY(n),
+                    offset,
+                    bootLibrary);
         } else {
-          addTokens(s, first, last, allocator, name, nameBase, line,
-                    lineLength, bootLibrary);
+          addTokens(s,
+                    first,
+                    last,
+                    allocator,
+                    name,
+                    nameBase,
+                    line,
+                    lineLength,
+                    bootLibrary);
         }
       }
 
@@ -764,20 +848,26 @@ addJar(System* s, Element** first, Element** last, Allocator* allocator,
   }
 }
 
-void
-add(System* s, Element** first, Element** last, Allocator* allocator,
-    const char* token, unsigned tokenLength, const char* bootLibrary)
+void add(System* s,
+         Element** first,
+         Element** last,
+         Allocator* allocator,
+         const char* token,
+         unsigned tokenLength,
+         const char* bootLibrary)
 {
   if (*token == '[' and token[tokenLength - 1] == ']') {
     char* name = static_cast<char*>(allocator->allocate(tokenLength - 1));
     memcpy(name, token + 1, tokenLength - 1);
-    name[tokenLength - 2] = 0; 
+    name[tokenLength - 2] = 0;
 
     if (DebugFind) {
       fprintf(stderr, "add builtin %s\n", name);
     }
-  
-    add(first, last, new (allocator->allocate(sizeof(BuiltinElement)))
+
+    add(first,
+        last,
+        new (allocator->allocate(sizeof(BuiltinElement)))
         BuiltinElement(s, allocator, name, bootLibrary));
   } else {
     char* name = static_cast<char*>(allocator->allocate(tokenLength + 1));
@@ -795,7 +885,9 @@ add(System* s, Element** first, Element** last, Allocator* allocator,
         fprintf(stderr, "add directory %s\n", name);
       }
 
-      add(first, last, new (allocator->allocate(sizeof(DirectoryElement)))
+      add(first,
+          last,
+          new (allocator->allocate(sizeof(DirectoryElement)))
           DirectoryElement(s, allocator, name));
     } break;
 
@@ -810,9 +902,10 @@ add(System* s, Element** first, Element** last, Allocator* allocator,
   }
 }
 
-Element*
-parsePath(System* s, Allocator* allocator, const char* path,
-          const char* bootLibrary)
+Element* parsePath(System* s,
+                   Allocator* allocator,
+                   const char* path,
+                   const char* bootLibrary)
 {
   Element* first = 0;
   Element* last = 0;
@@ -825,14 +918,18 @@ parsePath(System* s, Allocator* allocator, const char* path,
   return first;
 }
 
-class MyIterator: public Finder::IteratorImp {
+class MyIterator : public Finder::IteratorImp {
  public:
-  MyIterator(System* s, Allocator* allocator, Element* path):
-    s(s), allocator(allocator), e(path ? path->next : 0),
-    it(path ? path->iterator() : 0)
-  { }
+  MyIterator(System* s, Allocator* allocator, Element* path)
+      : s(s),
+        allocator(allocator),
+        e(path ? path->next : 0),
+        it(path ? path->iterator() : 0)
+  {
+  }
 
-  virtual const char* next(unsigned* size) {
+  virtual const char* next(unsigned* size)
+  {
     while (it) {
       const char* v = it->next(size);
       if (v) {
@@ -850,8 +947,10 @@ class MyIterator: public Finder::IteratorImp {
     return 0;
   }
 
-  virtual void dispose() {
-    if (it) it->dispose();
+  virtual void dispose()
+  {
+    if (it)
+      it->dispose();
     allocator->free(this, sizeof(*this));
   }
 
@@ -861,42 +960,51 @@ class MyIterator: public Finder::IteratorImp {
   Element::Iterator* it;
 };
 
-class MyFinder: public Finder {
+class MyFinder : public Finder {
  public:
-  MyFinder(System* system, Allocator* allocator, const char* path,
-           const char* bootLibrary):
-    system(system),
-    allocator(allocator),
-    path_(parsePath(system, allocator, path, bootLibrary)),
-    pathString(copy(allocator, path))
-  { }
-
-  MyFinder(System* system, Allocator* allocator, const uint8_t* jarData,
-           unsigned jarLength):
-    system(system),
-    allocator(allocator),
-    path_(new (allocator->allocate(sizeof(JarElement)))
-          JarElement(system, allocator, jarData, jarLength)),
-    pathString(0)
-  { }
-
-  virtual IteratorImp* iterator() {
-    return new (allocator->allocate(sizeof(MyIterator)))
-      MyIterator(system, allocator, path_);
+  MyFinder(System* system,
+           Allocator* allocator,
+           const char* path,
+           const char* bootLibrary)
+      : system(system),
+        allocator(allocator),
+        path_(parsePath(system, allocator, path, bootLibrary)),
+        pathString(copy(allocator, path))
+  {
   }
 
-  virtual System::Region* find(const char* name) {
+  MyFinder(System* system,
+           Allocator* allocator,
+           const uint8_t* jarData,
+           unsigned jarLength)
+      : system(system),
+        allocator(allocator),
+        path_(new (allocator->allocate(sizeof(JarElement)))
+              JarElement(system, allocator, jarData, jarLength)),
+        pathString(0)
+  {
+  }
+
+  virtual IteratorImp* iterator()
+  {
+    return new (allocator->allocate(sizeof(MyIterator)))
+        MyIterator(system, allocator, path_);
+  }
+
+  virtual System::Region* find(const char* name)
+  {
     for (Element* e = path_; e; e = e->next) {
       System::Region* r = e->find(name);
       if (r) {
         return r;
       }
     }
-    
+
     return 0;
   }
 
-  virtual System::FileType stat(const char* name, unsigned* length,
+  virtual System::FileType stat(const char* name,
+                                unsigned* length,
                                 bool tryDirectory)
   {
     for (Element* e = path_; e; e = e->next) {
@@ -905,19 +1013,19 @@ class MyFinder: public Finder {
         return type;
       }
     }
-    
+
     return System::TypeDoesNotExist;
   }
 
-  virtual const char* urlPrefix(const char* name) {
-    void *finderElementPtr = NULL;
+  virtual const char* urlPrefix(const char* name)
+  {
+    void* finderElementPtr = NULL;
     return nextUrlPrefix(name, finderElementPtr);
   }
 
-  virtual const char* nextUrlPrefix(const char* name,
-      void *&finderElementPtr)
+  virtual const char* nextUrlPrefix(const char* name, void*& finderElementPtr)
   {
-    Element *&e = reinterpret_cast<Element*&>(finderElementPtr);
+    Element*& e = reinterpret_cast<Element*&>(finderElementPtr);
     e = e ? e->next : path_;
     for (; e; e = e->next) {
       unsigned length;
@@ -930,7 +1038,8 @@ class MyFinder: public Finder {
     return 0;
   }
 
-  virtual const char* sourceUrl(const char* name) {
+  virtual const char* sourceUrl(const char* name)
+  {
     for (Element* e = path_; e; e = e->next) {
       unsigned length;
       System::FileType type = e->stat(name, &length, true);
@@ -942,11 +1051,13 @@ class MyFinder: public Finder {
     return 0;
   }
 
-  virtual const char* path() {
+  virtual const char* path()
+  {
     return pathString;
   }
 
-  virtual void dispose() {
+  virtual void dispose()
+  {
     for (Element* e = path_; e;) {
       Element* t = e;
       e = e->next;
@@ -964,21 +1075,24 @@ class MyFinder: public Finder {
   const char* pathString;
 };
 
-} // namespace
+}  // namespace
 
 namespace vm {
 
-AVIAN_EXPORT Finder*
-makeFinder(System* s, Allocator* a, const char* path, const char* bootLibrary)
+AVIAN_EXPORT Finder* makeFinder(System* s,
+                                Allocator* a,
+                                const char* path,
+                                const char* bootLibrary)
 {
   return new (a->allocate(sizeof(MyFinder))) MyFinder(s, a, path, bootLibrary);
 }
 
-Finder*
-makeFinder(System* s, Allocator* a, const uint8_t* jarData, unsigned jarLength)
+Finder* makeFinder(System* s,
+                   Allocator* a,
+                   const uint8_t* jarData,
+                   unsigned jarLength)
 {
-  return new (a->allocate(sizeof(MyFinder)))
-    MyFinder(s, a, jarData, jarLength);
+  return new (a->allocate(sizeof(MyFinder))) MyFinder(s, a, jarData, jarLength);
 }
 
-} // namespace vm
+}  // namespace vm
diff --git a/src/heap/heap.cpp b/src/heap/heap.cpp
index 64271967c7..54ce4a4209 100644
--- a/src/heap/heap.cpp
+++ b/src/heap/heap.cpp
@@ -38,15 +38,17 @@ const bool DebugAllocation = false;
 const bool DebugAllocation = true;
 #endif
 
-#define ACQUIRE(x) MutexLock MAKE_NAME(monitorLock_) (x)
+#define ACQUIRE(x) MutexLock MAKE_NAME(monitorLock_)(x)
 
 class MutexLock {
  public:
-  MutexLock(System::Mutex* m): m(m) {
+  MutexLock(System::Mutex* m) : m(m)
+  {
     m->acquire();
   }
 
-  ~MutexLock() {
+  ~MutexLock()
+  {
     m->release();
   }
 
@@ -64,40 +66,35 @@ void* allocate(Context* c, unsigned size, bool limit);
 void free(Context* c, const void* p, unsigned size);
 
 #ifdef USE_ATOMIC_OPERATIONS
-inline void
-markBitAtomic(uintptr_t* map, unsigned i)
+inline void markBitAtomic(uintptr_t* map, unsigned i)
 {
   uintptr_t* p = map + wordOf(i);
   uintptr_t v = static_cast<uintptr_t>(1) << bitOf(i);
-  for (uintptr_t old = *p;
-       not atomicCompareAndSwap(p, old, old | v);
-       old = *p)
-  { }
+  for (uintptr_t old = *p; not atomicCompareAndSwap(p, old, old | v);
+       old = *p) {
+  }
 }
-#endif // USE_ATOMIC_OPERATIONS
+#endif  // USE_ATOMIC_OPERATIONS
 
-inline void*
-get(void* o, unsigned offsetInWords)
+inline void* get(void* o, unsigned offsetInWords)
 {
-  return maskAlignedPointer(fieldAtOffset<void*>(o, offsetInWords * BytesPerWord));
+  return maskAlignedPointer(
+      fieldAtOffset<void*>(o, offsetInWords * BytesPerWord));
 }
 
-inline void**
-getp(void* o, unsigned offsetInWords)
+inline void** getp(void* o, unsigned offsetInWords)
 {
   return &fieldAtOffset<void*>(o, offsetInWords * BytesPerWord);
 }
 
-inline void
-set(void** o, void* value)
+inline void set(void** o, void* value)
 {
-  *o = reinterpret_cast<void*>
-    (reinterpret_cast<uintptr_t>(value)
-     | (reinterpret_cast<uintptr_t>(*o) & (~PointerMask)));
+  *o = reinterpret_cast<void*>(
+      reinterpret_cast<uintptr_t>(value)
+      | (reinterpret_cast<uintptr_t>(*o) & (~PointerMask)));
 }
 
-inline void
-set(void* o, unsigned offsetInWords, void* value)
+inline void set(void* o, unsigned offsetInWords, void* value)
 {
   set(getp(o, offsetInWords), value);
 }
@@ -111,42 +108,43 @@ class Segment {
       Map* map;
       unsigned index;
       unsigned limit;
-      
-      Iterator(Map* map, unsigned start, unsigned end):
-        map(map)
+
+      Iterator(Map* map, unsigned start, unsigned end) : map(map)
       {
         assertT(map->segment->context, map->bitsPerRecord == 1);
         assertT(map->segment->context, map->segment);
         assertT(map->segment->context, start <= map->segment->position());
 
-        if (end > map->segment->position()) end = map->segment->position();
+        if (end > map->segment->position())
+          end = map->segment->position();
 
         index = map->indexOf(start);
         limit = map->indexOf(end);
 
-        if ((end - start) % map->scale) ++ limit;
+        if ((end - start) % map->scale)
+          ++limit;
       }
 
-      bool hasMore() {
+      bool hasMore()
+      {
         unsigned word = wordOf(index);
         unsigned bit = bitOf(index);
         unsigned wordLimit = wordOf(limit);
         unsigned bitLimit = bitOf(limit);
 
         for (; word <= wordLimit and (word < wordLimit or bit < bitLimit);
-             ++word)
-        {
+             ++word) {
           uintptr_t w = map->data[word];
           if (2) {
             for (; bit < BitsPerWord and (word < wordLimit or bit < bitLimit);
-                 ++bit)
-            {
+                 ++bit) {
               if (w & (static_cast<uintptr_t>(1) << bit)) {
                 index = ::indexOf(word, bit);
                 //                 printf("hit at index %d\n", index);
                 return true;
               } else {
-                //                 printf("miss at index %d\n", indexOf(word, bit));
+                //                 printf("miss at index %d\n", indexOf(word,
+                //                 bit));
               }
             }
           }
@@ -157,8 +155,9 @@ class Segment {
 
         return false;
       }
-      
-      unsigned next() {
+
+      unsigned next()
+      {
         assertT(map->segment->context, hasMore());
         assertT(map->segment->context, map->segment);
 
@@ -173,34 +172,44 @@ class Segment {
     unsigned scale;
     bool clearNewData;
 
-    Map(Segment* segment, uintptr_t* data, unsigned bitsPerRecord,
-        unsigned scale, Map* child, bool clearNewData):
-      segment(segment),
-      child(child),
-      data(data),
-      bitsPerRecord(bitsPerRecord),
-      scale(scale),
-      clearNewData(clearNewData)
-    { }
+    Map(Segment* segment,
+        uintptr_t* data,
+        unsigned bitsPerRecord,
+        unsigned scale,
+        Map* child,
+        bool clearNewData)
+        : segment(segment),
+          child(child),
+          data(data),
+          bitsPerRecord(bitsPerRecord),
+          scale(scale),
+          clearNewData(clearNewData)
+    {
+    }
 
-    Map(Segment* segment, unsigned bitsPerRecord, unsigned scale, Map* child,
-        bool clearNewData):
-      segment(segment),
-      child(child),
-      data(0),
-      bitsPerRecord(bitsPerRecord),
-      scale(scale),
-      clearNewData(clearNewData)
-    { }
+    Map(Segment* segment,
+        unsigned bitsPerRecord,
+        unsigned scale,
+        Map* child,
+        bool clearNewData)
+        : segment(segment),
+          child(child),
+          data(0),
+          bitsPerRecord(bitsPerRecord),
+          scale(scale),
+          clearNewData(clearNewData)
+    {
+    }
 
-    void init() {
+    void init()
+    {
       assertT(segment->context, bitsPerRecord);
       assertT(segment->context, scale);
       assertT(segment->context, powerOfTwo(scale));
 
       if (data == 0) {
         data = segment->data + segment->capacity()
-          + calculateOffset(segment->capacity());
+               + calculateOffset(segment->capacity());
       }
 
       if (clearNewData) {
@@ -212,36 +221,45 @@ class Segment {
       }
     }
 
-    unsigned calculateOffset(unsigned capacity) {
+    unsigned calculateOffset(unsigned capacity)
+    {
       unsigned n = 0;
-      if (child) n += child->calculateFootprint(capacity);
+      if (child)
+        n += child->calculateFootprint(capacity);
       return n;
     }
 
-    static unsigned calculateSize(Context* c UNUSED, unsigned capacity,
-                                  unsigned scale, unsigned bitsPerRecord)
+    static unsigned calculateSize(Context* c UNUSED,
+                                  unsigned capacity,
+                                  unsigned scale,
+                                  unsigned bitsPerRecord)
     {
-      unsigned result
-        = ceilingDivide(ceilingDivide(capacity, scale) * bitsPerRecord, BitsPerWord);
+      unsigned result = ceilingDivide(
+          ceilingDivide(capacity, scale) * bitsPerRecord, BitsPerWord);
       assertT(c, result);
       return result;
     }
 
-    unsigned calculateSize(unsigned capacity) {
+    unsigned calculateSize(unsigned capacity)
+    {
       return calculateSize(segment->context, capacity, scale, bitsPerRecord);
     }
 
-    unsigned size() {
+    unsigned size()
+    {
       return calculateSize(segment->capacity());
     }
 
-    unsigned calculateFootprint(unsigned capacity) {
+    unsigned calculateFootprint(unsigned capacity)
+    {
       unsigned n = calculateSize(capacity);
-      if (child) n += child->calculateFootprint(capacity);
+      if (child)
+        n += child->calculateFootprint(capacity);
       return n;
     }
 
-    void replaceWith(Map* m) {
+    void replaceWith(Map* m)
+    {
       assertT(segment->context, bitsPerRecord == m->bitsPerRecord);
       assertT(segment->context, scale == m->scale);
 
@@ -249,77 +267,95 @@ class Segment {
 
       m->segment = 0;
       m->data = 0;
-      
-      if (child) child->replaceWith(m->child);
+
+      if (child)
+        child->replaceWith(m->child);
     }
 
-    unsigned indexOf(unsigned segmentIndex) {
+    unsigned indexOf(unsigned segmentIndex)
+    {
       return (segmentIndex / scale) * bitsPerRecord;
     }
 
-    unsigned indexOf(void* p) {
+    unsigned indexOf(void* p)
+    {
       assertT(segment->context, segment->almostContains(p));
       assertT(segment->context, segment->capacity());
       return indexOf(segment->indexOf(p));
     }
 
-    void clearBit(unsigned i) {
+    void clearBit(unsigned i)
+    {
       assertT(segment->context, wordOf(i) < size());
 
       vm::clearBit(data, i);
     }
 
-    void setBit(unsigned i) {
+    void setBit(unsigned i)
+    {
       assertT(segment->context, wordOf(i) < size());
 
       vm::markBit(data, i);
     }
 
-    void clearOnlyIndex(unsigned index) {
+    void clearOnlyIndex(unsigned index)
+    {
       clearBits(data, bitsPerRecord, index);
     }
 
-    void clearOnly(unsigned segmentIndex) {
+    void clearOnly(unsigned segmentIndex)
+    {
       clearOnlyIndex(indexOf(segmentIndex));
     }
 
-    void clearOnly(void* p) {
+    void clearOnly(void* p)
+    {
       clearOnlyIndex(indexOf(p));
     }
 
-    void clear(void* p) {
+    void clear(void* p)
+    {
       clearOnly(p);
-      if (child) child->clear(p);
+      if (child)
+        child->clear(p);
     }
 
-    void setOnlyIndex(unsigned index, unsigned v = 1) {
+    void setOnlyIndex(unsigned index, unsigned v = 1)
+    {
       setBits(data, bitsPerRecord, index, v);
     }
 
-    void setOnly(unsigned segmentIndex, unsigned v = 1) {
+    void setOnly(unsigned segmentIndex, unsigned v = 1)
+    {
       setOnlyIndex(indexOf(segmentIndex), v);
     }
 
-    void setOnly(void* p, unsigned v = 1) {
+    void setOnly(void* p, unsigned v = 1)
+    {
       setOnlyIndex(indexOf(p), v);
     }
 
-    void set(void* p, unsigned v = 1) {
+    void set(void* p, unsigned v = 1)
+    {
       setOnly(p, v);
       assertT(segment->context, get(p) == v);
-      if (child) child->set(p, v);
+      if (child)
+        child->set(p, v);
     }
 
 #ifdef USE_ATOMIC_OPERATIONS
-    void markAtomic(void* p) {
+    void markAtomic(void* p)
+    {
       assertT(segment->context, bitsPerRecord == 1);
       markBitAtomic(data, indexOf(p));
       assertT(segment->context, getBit(data, indexOf(p)));
-      if (child) child->markAtomic(p);
+      if (child)
+        child->markAtomic(p);
     }
 #endif
 
-    unsigned get(void* p) {
+    unsigned get(void* p)
+    {
       return getBits(data, bitsPerRecord, indexOf(p));
     }
   };
@@ -330,13 +366,12 @@ class Segment {
   unsigned capacity_;
   Map* map;
 
-  Segment(Context* context, Map* map, unsigned desired, unsigned minimum,
-          int64_t available = INT64_MAX):
-    context(context),
-    data(0),
-    position_(0),
-    capacity_(0),
-    map(map)
+  Segment(Context* context,
+          Map* map,
+          unsigned desired,
+          unsigned minimum,
+          int64_t available = INT64_MAX)
+      : context(context), data(0), position_(0), capacity_(0), map(map)
   {
     if (desired) {
       if (minimum == 0) {
@@ -356,17 +391,15 @@ class Segment {
             if (bottom == capacity_) {
               break;
             } else if (static_cast<int64_t>(footprint(capacity_ - 1))
-                       <= target)
-            {
-              -- capacity_;
+                       <= target) {
+              --capacity_;
               break;
             }
             top = capacity_;
             capacity_ = avg(bottom, capacity_);
           } else if (static_cast<int64_t>(footprint(capacity_)) < target) {
             if (top == capacity_
-                or static_cast<int64_t>(footprint(capacity_ + 1)) >= target)
-            {
+                or static_cast<int64_t>(footprint(capacity_ + 1)) >= target) {
               break;
             }
             bottom = capacity_;
@@ -378,9 +411,8 @@ class Segment {
       }
 
       while (data == 0) {
-        data = static_cast<uintptr_t*>
-          (local::allocate
-           (context, (footprint(capacity_)) * BytesPerWord, false));
+        data = static_cast<uintptr_t*>(local::allocate(
+            context, (footprint(capacity_)) * BytesPerWord, false));
 
         if (data == 0) {
           if (capacity_ > minimum) {
@@ -389,9 +421,8 @@ class Segment {
               break;
             }
           } else {
-            data = static_cast<uintptr_t*>
-              (local::allocate
-               (context, (footprint(capacity_)) * BytesPerWord));
+            data = static_cast<uintptr_t*>(local::allocate(
+                context, (footprint(capacity_)) * BytesPerWord));
           }
         }
       }
@@ -402,37 +433,45 @@ class Segment {
     }
   }
 
-  Segment(Context* context, Map* map, uintptr_t* data, unsigned position,
-          unsigned capacity):
-    context(context),
-    data(data),
-    position_(position),
-    capacity_(capacity),
-    map(map)
+  Segment(Context* context,
+          Map* map,
+          uintptr_t* data,
+          unsigned position,
+          unsigned capacity)
+      : context(context),
+        data(data),
+        position_(position),
+        capacity_(capacity),
+        map(map)
   {
     if (map) {
       map->init();
     }
   }
 
-  unsigned footprint(unsigned capacity) {
+  unsigned footprint(unsigned capacity)
+  {
     return capacity
-      + (map and capacity ? map->calculateFootprint(capacity) : 0);
+           + (map and capacity ? map->calculateFootprint(capacity) : 0);
   }
 
-  unsigned capacity() {
+  unsigned capacity()
+  {
     return capacity_;
   }
 
-  unsigned position() {
+  unsigned position()
+  {
     return position_;
   }
 
-  unsigned remaining() {
+  unsigned remaining()
+  {
     return capacity() - position();
   }
 
-  void replaceWith(Segment* s) {
+  void replaceWith(Segment* s)
+  {
     if (data) {
       free(context, data, (footprint(capacity())) * BytesPerWord);
     }
@@ -454,28 +493,33 @@ class Segment {
       }
     } else {
       assertT(context, map == 0);
-    }    
+    }
   }
 
-  bool contains(void* p) {
+  bool contains(void* p)
+  {
     return position() and p >= data and p < data + position();
   }
 
-  bool almostContains(void* p) {
+  bool almostContains(void* p)
+  {
     return contains(p) or p == data + position();
   }
 
-  void* get(unsigned offset) {
+  void* get(unsigned offset)
+  {
     assertT(context, offset <= position());
     return data + offset;
   }
 
-  unsigned indexOf(void* p) {
+  unsigned indexOf(void* p)
+  {
     assertT(context, almostContains(p));
     return static_cast<uintptr_t*>(p) - data;
   }
 
-  void* allocate(unsigned size) {
+  void* allocate(unsigned size)
+  {
     assertT(context, size);
     assertT(context, position() + size <= capacity());
 
@@ -484,7 +528,8 @@ class Segment {
     return p;
   }
 
-  void dispose() {
+  void dispose()
+  {
     if (data) {
       free(context, data, (footprint(capacity())) * BytesPerWord);
     }
@@ -500,13 +545,12 @@ class Fixie {
   static const unsigned Dirty = 1 << 2;
   static const unsigned Dead = 1 << 3;
 
-  Fixie(Context* c, unsigned size, bool hasMask, Fixie** handle,
-        bool immortal):
-    age(immortal ? FixieTenureThreshold + 1 : 0),
-    flags(hasMask ? HasMask : 0),
-    size(size),
-    next(0),
-    handle(0)
+  Fixie(Context* c, unsigned size, bool hasMask, Fixie** handle, bool immortal)
+      : age(immortal ? FixieTenureThreshold + 1 : 0),
+        flags(hasMask ? HasMask : 0),
+        size(size),
+        next(0),
+        handle(0)
   {
     memset(mask(), 0, maskSize(size, hasMask));
     add(c, handle);
@@ -515,25 +559,29 @@ class Fixie {
     }
   }
 
-  bool immortal() {
+  bool immortal()
+  {
     return age == FixieTenureThreshold + 1;
   }
 
-  void add(Context* c UNUSED, Fixie** handle) {
+  void add(Context* c UNUSED, Fixie** handle)
+  {
     assertT(c, this->handle == 0);
     assertT(c, next == 0);
 
     this->handle = handle;
     if (handle) {
       next = *handle;
-      if (next) next->handle = &next;
+      if (next)
+        next->handle = &next;
       *handle = this;
     } else {
       next = 0;
     }
   }
 
-  void remove(Context* c UNUSED) {
+  void remove(Context* c UNUSED)
+  {
     if (handle) {
       assertT(c, *handle == this);
       *handle = next;
@@ -545,7 +593,8 @@ class Fixie {
     handle = 0;
   }
 
-  void move(Context* c, Fixie** handle) {
+  void move(Context* c, Fixie** handle)
+  {
     if (DebugFixies) {
       fprintf(stderr, "move fixie %p\n", this);
     }
@@ -554,35 +603,43 @@ class Fixie {
     add(c, handle);
   }
 
-  void** body() {
+  void** body()
+  {
     return static_cast<void**>(static_cast<void*>(body_));
   }
 
-  uintptr_t* mask() {
+  uintptr_t* mask()
+  {
     return body_ + size;
   }
 
-  static unsigned maskSize(unsigned size, bool hasMask) {
+  static unsigned maskSize(unsigned size, bool hasMask)
+  {
     return hasMask * ceilingDivide(size, BitsPerWord) * BytesPerWord;
   }
 
-  static unsigned totalSize(unsigned size, bool hasMask) {
+  static unsigned totalSize(unsigned size, bool hasMask)
+  {
     return sizeof(Fixie) + (size * BytesPerWord) + maskSize(size, hasMask);
   }
 
-  unsigned totalSize() {
+  unsigned totalSize()
+  {
     return totalSize(size, hasMask());
   }
 
-  bool hasMask() {
+  bool hasMask()
+  {
     return (flags & HasMask) != 0;
   }
 
-  bool marked() {
+  bool marked()
+  {
     return (flags & Marked) != 0;
   }
 
-  void marked(bool v) {
+  void marked(bool v)
+  {
     if (v) {
       flags |= Marked;
     } else {
@@ -590,11 +647,13 @@ class Fixie {
     }
   }
 
-  bool dirty() {
+  bool dirty()
+  {
     return (flags & Dirty) != 0;
   }
 
-  void dirty(bool v) {
+  void dirty(bool v)
+  {
     if (v) {
       flags |= Dirty;
     } else {
@@ -602,11 +661,13 @@ class Fixie {
     }
   }
 
-  bool dead() {
+  bool dead()
+  {
     return (flags & Dead) != 0;
   }
 
-  void dead(bool v) {
+  void dead(bool v)
+  {
     if (v) {
       flags |= Dead;
     } else {
@@ -625,77 +686,72 @@ class Fixie {
   uintptr_t body_[0];
 };
 
-Fixie*
-fixie(void* body)
+Fixie* fixie(void* body)
 {
   return static_cast<Fixie*>(body) - 1;
 }
 
-void
-free(Context* c, Fixie** fixies, bool resetImmortal = false);
+void free(Context* c, Fixie** fixies, bool resetImmortal = false);
 
 class Context {
  public:
-  Context(System* system, unsigned limit):
-    system(system),
-    client(0),
-    count(0),
-    limit(limit),
-    lock(0),
-    
-    immortalHeapStart(0),
-    immortalHeapEnd(0),
-
-    ageMap(&gen1, max(1, log(TenureThreshold)), 1, 0, false),
-    gen1(this, &ageMap, 0, 0),
-
-    nextAgeMap(&nextGen1, max(1, log(TenureThreshold)), 1, 0, false),
-    nextGen1(this, &nextAgeMap, 0, 0),
-
-    pointerMap(&gen2, 1, 1, 0, true),
-    pageMap(&gen2, 1, LikelyPageSizeInBytes / BytesPerWord, &pointerMap, true),
-    heapMap(&gen2, 1, pageMap.scale * 1024, &pageMap, true),
-    gen2(this, &heapMap, 0, 0),
-
-    nextPointerMap(&nextGen2, 1, 1, 0, true),
-    nextPageMap(&nextGen2, 1, LikelyPageSizeInBytes / BytesPerWord,
-                &nextPointerMap, true),
-    nextHeapMap(&nextGen2, 1, nextPageMap.scale * 1024, &nextPageMap, true),
-    nextGen2(this, &nextHeapMap, 0, 0),
-
-    gen2Base(0),
-    incomingFootprint(0),
-    pendingAllocation(0),
-    tenureFootprint(0),
-    gen1Padding(0),
-    tenurePadding(0),
-    gen2Padding(0),
-
-    fixieTenureFootprint(0),
-    untenuredFixieFootprint(0),
-    tenuredFixieFootprint(0),
-    tenuredFixieCeiling(InitialTenuredFixieCeilingInBytes),
-
-    mode(Heap::MinorCollection),
-
-    fixies(0),
-    tenuredFixies(0),
-    dirtyTenuredFixies(0),
-    markedFixies(0),
-    visitedFixies(0),
-
-    lastCollectionTime(system->now()),
-    totalCollectionTime(0),
-    totalTime(0),
-
-    limitWasExceeded(false)
+  Context(System* system, unsigned limit)
+      : system(system),
+        client(0),
+        count(0),
+        limit(limit),
+        lock(0),
+        immortalHeapStart(0),
+        immortalHeapEnd(0),
+        ageMap(&gen1, max(1, log(TenureThreshold)), 1, 0, false),
+        gen1(this, &ageMap, 0, 0),
+        nextAgeMap(&nextGen1, max(1, log(TenureThreshold)), 1, 0, false),
+        nextGen1(this, &nextAgeMap, 0, 0),
+        pointerMap(&gen2, 1, 1, 0, true),
+        pageMap(&gen2,
+                1,
+                LikelyPageSizeInBytes / BytesPerWord,
+                &pointerMap,
+                true),
+        heapMap(&gen2, 1, pageMap.scale * 1024, &pageMap, true),
+        gen2(this, &heapMap, 0, 0),
+        nextPointerMap(&nextGen2, 1, 1, 0, true),
+        nextPageMap(&nextGen2,
+                    1,
+                    LikelyPageSizeInBytes / BytesPerWord,
+                    &nextPointerMap,
+                    true),
+        nextHeapMap(&nextGen2, 1, nextPageMap.scale * 1024, &nextPageMap, true),
+        nextGen2(this, &nextHeapMap, 0, 0),
+        gen2Base(0),
+        incomingFootprint(0),
+        pendingAllocation(0),
+        tenureFootprint(0),
+        gen1Padding(0),
+        tenurePadding(0),
+        gen2Padding(0),
+        fixieTenureFootprint(0),
+        untenuredFixieFootprint(0),
+        tenuredFixieFootprint(0),
+        tenuredFixieCeiling(InitialTenuredFixieCeilingInBytes),
+        mode(Heap::MinorCollection),
+        fixies(0),
+        tenuredFixies(0),
+        dirtyTenuredFixies(0),
+        markedFixies(0),
+        visitedFixies(0),
+        lastCollectionTime(system->now()),
+        totalCollectionTime(0),
+        totalTime(0),
+        limitWasExceeded(false)
   {
     if (not system->success(system->make(&lock))) {
       system->abort();
     }
   }
 
-  void dispose() {
+  void dispose()
+  {
     gen1.dispose();
     nextGen1.dispose();
     gen2.dispose();
@@ -703,7 +759,8 @@ class Context {
     lock->dispose();
   }
 
-  void disposeFixies() {
+  void disposeFixies()
+  {
     free(this, &tenuredFixies, true);
     free(this, &dirtyTenuredFixies, true);
     free(this, &fixies, true);
@@ -737,7 +794,7 @@ class Context {
   Segment nextGen2;
 
   unsigned gen2Base;
-  
+
   unsigned incomingFootprint;
   int pendingAllocation;
   unsigned tenureFootprint;
@@ -765,8 +822,7 @@ class Context {
   bool limitWasExceeded;
 };
 
-const char*
-segment(Context* c, void* p)
+const char* segment(Context* c, void* p)
 {
   if (c->gen1.contains(p)) {
     return "gen1";
@@ -781,36 +837,33 @@ segment(Context* c, void* p)
   }
 }
 
-inline Aborter* getAborter(Context* c) {
+inline Aborter* getAborter(Context* c)
+{
   return c->system;
 }
 
-inline unsigned
-minimumNextGen1Capacity(Context* c)
+inline unsigned minimumNextGen1Capacity(Context* c)
 {
   return c->gen1.position() - c->tenureFootprint + c->incomingFootprint
-    + c->gen1Padding;
+         + c->gen1Padding;
 }
 
-inline unsigned
-minimumNextGen2Capacity(Context* c)
+inline unsigned minimumNextGen2Capacity(Context* c)
 {
   return c->gen2.position() + c->tenureFootprint + c->tenurePadding
-    + c->gen2Padding;
+         + c->gen2Padding;
 }
 
-inline bool
-oversizedGen2(Context* c)
+inline bool oversizedGen2(Context* c)
 {
   return c->gen2.capacity() > (InitialGen2CapacityInBytes / BytesPerWord)
-    and c->gen2.position() < (c->gen2.capacity() / 4);
+         and c->gen2.position() < (c->gen2.capacity() / 4);
 }
 
-inline void
-initNextGen1(Context* c)
+inline void initNextGen1(Context* c)
 {
-  new (&(c->nextAgeMap)) Segment::Map
-    (&(c->nextGen1), max(1, log(TenureThreshold)), 1, 0, false);
+  new (&(c->nextAgeMap))
+      Segment::Map(&(c->nextGen1), max(1, log(TenureThreshold)), 1, 0, false);
 
   unsigned minimum = minimumNextGen1Capacity(c);
   unsigned desired = minimum;
@@ -818,23 +871,24 @@ initNextGen1(Context* c)
   new (&(c->nextGen1)) Segment(c, &(c->nextAgeMap), desired, minimum);
 
   if (Verbose2) {
-    fprintf(stderr, "init nextGen1 to %d bytes\n",
+    fprintf(stderr,
+            "init nextGen1 to %d bytes\n",
             c->nextGen1.capacity() * BytesPerWord);
   }
 }
 
-inline void
-initNextGen2(Context* c)
+inline void initNextGen2(Context* c)
 {
-  new (&(c->nextPointerMap)) Segment::Map
-    (&(c->nextGen2), 1, 1, 0, true);
+  new (&(c->nextPointerMap)) Segment::Map(&(c->nextGen2), 1, 1, 0, true);
 
-  new (&(c->nextPageMap)) Segment::Map
-    (&(c->nextGen2), 1, LikelyPageSizeInBytes / BytesPerWord,
-     &(c->nextPointerMap), true);
+  new (&(c->nextPageMap)) Segment::Map(&(c->nextGen2),
+                                       1,
+                                       LikelyPageSizeInBytes / BytesPerWord,
+                                       &(c->nextPointerMap),
+                                       true);
 
-  new (&(c->nextHeapMap)) Segment::Map
-    (&(c->nextGen2), 1, c->pageMap.scale * 1024, &(c->nextPageMap), true);
+  new (&(c->nextHeapMap)) Segment::Map(
+      &(c->nextGen2), 1, c->pageMap.scale * 1024, &(c->nextPageMap), true);
 
   unsigned minimum = minimumNextGen2Capacity(c);
   unsigned desired = minimum;
@@ -847,57 +901,53 @@ initNextGen2(Context* c)
     desired = InitialGen2CapacityInBytes / BytesPerWord;
   }
 
-  new (&(c->nextGen2)) Segment
-    (c, &(c->nextHeapMap), desired, minimum,
-     static_cast<int64_t>(c->limit / BytesPerWord)
-     - (static_cast<int64_t>(c->count / BytesPerWord)
-        - c->gen2.footprint(c->gen2.capacity())
-        - c->gen1.footprint(c->gen1.capacity())
-        + c->pendingAllocation));
+  new (&(c->nextGen2)) Segment(
+      c,
+      &(c->nextHeapMap),
+      desired,
+      minimum,
+      static_cast<int64_t>(c->limit / BytesPerWord)
+      - (static_cast<int64_t>(c->count / BytesPerWord)
+         - c->gen2.footprint(c->gen2.capacity())
+         - c->gen1.footprint(c->gen1.capacity()) + c->pendingAllocation));
 
   if (Verbose2) {
-    fprintf(stderr, "init nextGen2 to %d bytes\n",
+    fprintf(stderr,
+            "init nextGen2 to %d bytes\n",
             c->nextGen2.capacity() * BytesPerWord);
   }
 }
 
-inline bool
-fresh(Context* c, void* o)
+inline bool fresh(Context* c, void* o)
 {
-  return c->nextGen1.contains(o)
-    or c->nextGen2.contains(o)
-    or (c->gen2.contains(o) and c->gen2.indexOf(o) >= c->gen2Base);
+  return c->nextGen1.contains(o) or c->nextGen2.contains(o)
+         or (c->gen2.contains(o) and c->gen2.indexOf(o) >= c->gen2Base);
 }
 
-inline bool
-wasCollected(Context* c, void* o)
+inline bool wasCollected(Context* c, void* o)
 {
   return o and (not fresh(c, o)) and fresh(c, get(o, 0));
 }
 
-inline void*
-follow(Context* c UNUSED, void* o)
+inline void* follow(Context* c UNUSED, void* o)
 {
   assertT(c, wasCollected(c, o));
   return fieldAtOffset<void*>(o, 0);
 }
 
-inline void*&
-parent(Context* c UNUSED, void* o)
+inline void*& parent(Context* c UNUSED, void* o)
 {
   assertT(c, wasCollected(c, o));
   return fieldAtOffset<void*>(o, BytesPerWord);
 }
 
-inline uintptr_t*
-bitset(Context* c UNUSED, void* o)
+inline uintptr_t* bitset(Context* c UNUSED, void* o)
 {
   assertT(c, wasCollected(c, o));
   return &fieldAtOffset<uintptr_t>(o, BytesPerWord * 2);
 }
 
-void
-free(Context* c, Fixie** fixies, bool resetImmortal)
+void free(Context* c, Fixie** fixies, bool resetImmortal)
 {
   for (Fixie** p = fixies; *p;) {
     Fixie* f = *p;
@@ -913,7 +963,7 @@ free(Context* c, Fixie** fixies, bool resetImmortal)
         f->handle = 0;
         f->marked(false);
         f->dirty(false);
-      } else {      
+      } else {
         p = &(f->next);
       }
     } else {
@@ -926,18 +976,16 @@ free(Context* c, Fixie** fixies, bool resetImmortal)
   }
 }
 
-void
-kill(Fixie* fixies)
+void kill(Fixie* fixies)
 {
   for (Fixie* f = fixies; f; f = f->next) {
-    if (! f->immortal()) {
+    if (!f->immortal()) {
       f->dead(true);
     }
   }
 }
 
-void
-killFixies(Context* c)
+void killFixies(Context* c)
 {
   assertT(c, c->markedFixies == 0);
 
@@ -948,8 +996,7 @@ killFixies(Context* c)
   kill(c->fixies);
 }
 
-void
-sweepFixies(Context* c)
+void sweepFixies(Context* c)
 {
   assertT(c, c->markedFixies == 0);
 
@@ -968,7 +1015,7 @@ sweepFixies(Context* c)
     f->remove(c);
 
     if (not f->immortal()) {
-      ++ f->age;
+      ++f->age;
       if (f->age > FixieTenureThreshold) {
         f->age = FixieTenureThreshold;
       } else if (static_cast<unsigned>(f->age + 1) == FixieTenureThreshold) {
@@ -999,13 +1046,11 @@ sweepFixies(Context* c)
     f->marked(false);
   }
 
-  c->tenuredFixieCeiling = max
-    (c->tenuredFixieFootprint * 2,
-     InitialTenuredFixieCeilingInBytes);
+  c->tenuredFixieCeiling
+      = max(c->tenuredFixieFootprint * 2, InitialTenuredFixieCeilingInBytes);
 }
 
-inline void*
-copyTo(Context* c, Segment* s, void* o, unsigned size)
+inline void* copyTo(Context* c, Segment* s, void* o, unsigned size)
 {
   assertT(c, s->remaining() >= size);
   void* dst = s->allocate(size);
@@ -1013,14 +1058,12 @@ copyTo(Context* c, Segment* s, void* o, unsigned size)
   return dst;
 }
 
-bool
-immortalHeapContains(Context* c, void* p)
+bool immortalHeapContains(Context* c, void* p)
 {
   return p < c->immortalHeapEnd and p >= c->immortalHeapStart;
 }
 
-void*
-copy2(Context* c, void* o)
+void* copy2(Context* c, void* o)
 {
   unsigned size = c->client->copiedSizeInWords(o);
 
@@ -1065,14 +1108,17 @@ copy2(Context* c, void* o)
   }
 }
 
-void*
-copy(Context* c, void* o)
+void* copy(Context* c, void* o)
 {
   void* r = copy2(c, o);
 
   if (Debug) {
-    fprintf(stderr, "copy %p (%s) to %p (%s)\n",
-            o, segment(c, o), r, segment(c, r));
+    fprintf(stderr,
+            "copy %p (%s) to %p (%s)\n",
+            o,
+            segment(c, o),
+            r,
+            segment(c, r));
   }
 
   // leave a pointer to the copy in the original
@@ -1081,15 +1127,12 @@ copy(Context* c, void* o)
   return r;
 }
 
-void*
-update3(Context* c, void* o, bool* needsVisit)
+void* update3(Context* c, void* o, bool* needsVisit)
 {
   if (c->client->isFixed(o)) {
     Fixie* f = fixie(o);
-    if ((not f->marked())
-        and (c->mode == Heap::MajorCollection
-             or f->age < FixieTenureThreshold))
-    {
+    if ((not f->marked()) and (c->mode == Heap::MajorCollection
+                               or f->age < FixieTenureThreshold)) {
       if (DebugFixies) {
         fprintf(stderr, "mark fixie %p\n", f);
       }
@@ -1101,7 +1144,7 @@ update3(Context* c, void* o, bool* needsVisit)
     return o;
   } else if (immortalHeapContains(c, o)) {
     *needsVisit = false;
-    return o;    
+    return o;
   } else if (wasCollected(c, o)) {
     *needsVisit = false;
     return follow(c, o);
@@ -1111,8 +1154,7 @@ update3(Context* c, void* o, bool* needsVisit)
   }
 }
 
-void*
-update2(Context* c, void* o, bool* needsVisit)
+void* update2(Context* c, void* o, bool* needsVisit)
 {
   if (c->mode == Heap::MinorCollection and c->gen2.contains(o)) {
     *needsVisit = false;
@@ -1122,8 +1164,7 @@ update2(Context* c, void* o, bool* needsVisit)
   return update3(c, o, needsVisit);
 }
 
-void
-markDirty(Context* c, Fixie* f)
+void markDirty(Context* c, Fixie* f)
 {
   if (not f->dirty()) {
 #ifdef USE_ATOMIC_OPERATIONS
@@ -1137,8 +1178,7 @@ markDirty(Context* c, Fixie* f)
   }
 }
 
-void
-markClean(Context* c, Fixie* f)
+void markClean(Context* c, Fixie* f)
 {
   if (f->dirty()) {
     f->dirty(false);
@@ -1150,8 +1190,11 @@ markClean(Context* c, Fixie* f)
   }
 }
 
-void
-updateHeapMap(Context* c, void* p, void* target, unsigned offset, void* result)
+void updateHeapMap(Context* c,
+                   void* p,
+                   void* target,
+                   unsigned offset,
+                   void* result)
 {
   Segment* seg;
   Segment::Map* map;
@@ -1164,28 +1207,35 @@ updateHeapMap(Context* c, void* p, void* target, unsigned offset, void* result)
     map = &(c->nextHeapMap);
   }
 
-  if (not (immortalHeapContains(c, result)
-           or (c->client->isFixed(result)
-               and fixie(result)->age >= FixieTenureThreshold)
-           or seg->contains(result)))
-  {
+  if (not(immortalHeapContains(c, result)
+          or (c->client->isFixed(result)
+              and fixie(result)->age >= FixieTenureThreshold)
+          or seg->contains(result))) {
     if (target and c->client->isFixed(target)) {
       Fixie* f = fixie(target);
       assertT(c, offset == 0 or f->hasMask());
 
       if (static_cast<unsigned>(f->age + 1) >= FixieTenureThreshold) {
         if (DebugFixies) {
-          fprintf(stderr, "dirty fixie %p at %d (%p): %p\n",
-                  f, offset, f->body() + offset, result);
+          fprintf(stderr,
+                  "dirty fixie %p at %d (%p): %p\n",
+                  f,
+                  offset,
+                  f->body() + offset,
+                  result);
         }
 
         f->dirty(true);
         markBit(f->mask(), offset);
       }
     } else if (seg->contains(p)) {
-      if (Debug) {        
-        fprintf(stderr, "mark %p (%s) at %p (%s)\n",
-                result, segment(c, result), p, segment(c, p));
+      if (Debug) {
+        fprintf(stderr,
+                "mark %p (%s) at %p (%s)\n",
+                result,
+                segment(c, result),
+                p,
+                segment(c, p));
       }
 
       map->set(p);
@@ -1193,8 +1243,11 @@ updateHeapMap(Context* c, void* p, void* target, unsigned offset, void* result)
   }
 }
 
-void*
-update(Context* c, void** p, void* target, unsigned offset, bool* needsVisit)
+void* update(Context* c,
+             void** p,
+             void* target,
+             unsigned offset,
+             bool* needsVisit)
 {
   if (maskAlignedPointer(*p) == 0) {
     *needsVisit = false;
@@ -1211,16 +1264,14 @@ update(Context* c, void** p, void* target, unsigned offset, bool* needsVisit)
 }
 
 const uintptr_t BitsetExtensionBit
-= (static_cast<uintptr_t>(1) << (BitsPerWord - 1));
+    = (static_cast<uintptr_t>(1) << (BitsPerWord - 1));
 
-void
-bitsetInit(uintptr_t* p)
+void bitsetInit(uintptr_t* p)
 {
   memset(p, 0, BytesPerWord);
 }
 
-void
-bitsetClear(uintptr_t* p, unsigned start, unsigned end)
+void bitsetClear(uintptr_t* p, unsigned start, unsigned end)
 {
   if (end < BitsPerWord - 1) {
     // do nothing
@@ -1235,14 +1286,14 @@ bitsetClear(uintptr_t* p, unsigned start, unsigned end)
   }
 }
 
-void
-bitsetSet(uintptr_t* p, unsigned i, bool v)
+void bitsetSet(uintptr_t* p, unsigned i, bool v)
 {
   if (i >= BitsPerWord - 1) {
     i += (BitsPerWord * 2) + 1;
     if (v) {
       p[0] |= BitsetExtensionBit;
-      if (p[2] <= wordOf(i) - 3) p[2] = wordOf(i) - 2;
+      if (p[2] <= wordOf(i) - 3)
+        p[2] = wordOf(i) - 2;
     }
   }
 
@@ -1253,11 +1304,11 @@ bitsetSet(uintptr_t* p, unsigned i, bool v)
   }
 }
 
-bool
-bitsetHasMore(uintptr_t* p)
+bool bitsetHasMore(uintptr_t* p)
 {
   switch (*p) {
-  case 0: return false;
+  case 0:
+    return false;
 
   case BitsetExtensionBit: {
     uintptr_t length = p[2];
@@ -1272,18 +1323,19 @@ bitsetHasMore(uintptr_t* p)
     return false;
   }
 
-  default: return true;
+  default:
+    return true;
   }
 }
 
-unsigned
-bitsetNext(Context* c, uintptr_t* p)
+unsigned bitsetNext(Context* c, uintptr_t* p)
 {
   bool more UNUSED = bitsetHasMore(p);
   assertT(c, more);
 
   switch (*p) {
-  case 0: abort(c);
+  case 0:
+    abort(c);
 
   case BitsetExtensionBit: {
     uintptr_t i = p[1];
@@ -1311,151 +1363,163 @@ bitsetNext(Context* c, uintptr_t* p)
   }
 }
 
-void
-collect(Context* c, void** p, void* target, unsigned offset)
+void collect(Context* c, void** p, void* target, unsigned offset)
 {
   void* original = maskAlignedPointer(*p);
   void* parent_ = 0;
-  
+
   if (Debug) {
-    fprintf(stderr, "update %p (%s) at %p (%s)\n",
-            maskAlignedPointer(*p), segment(c, *p), p, segment(c, p));
+    fprintf(stderr,
+            "update %p (%s) at %p (%s)\n",
+            maskAlignedPointer(*p),
+            segment(c, *p),
+            p,
+            segment(c, p));
   }
 
   bool needsVisit;
   local::set(p, update(c, maskAlignedPointer(p), target, offset, &needsVisit));
 
   if (Debug) {
-    fprintf(stderr, "  result: %p (%s) (visit? %d)\n",
-            maskAlignedPointer(*p), segment(c, *p), needsVisit);
+    fprintf(stderr,
+            "  result: %p (%s) (visit? %d)\n",
+            maskAlignedPointer(*p),
+            segment(c, *p),
+            needsVisit);
   }
 
-  if (not needsVisit) return;
+  if (not needsVisit)
+    return;
 
- visit: {
-    void* copy = follow(c, original);
+visit : {
+  void* copy = follow(c, original);
 
-    class Walker : public Heap::Walker {
-     public:
-      Walker(Context* c, void* copy, uintptr_t* bitset):
-        c(c),
-        copy(copy),
-        bitset(bitset),
-        first(0),
-        second(0),
-        last(0),
-        visits(0),
-        total(0)
-      { }
+  class Walker : public Heap::Walker {
+   public:
+    Walker(Context* c, void* copy, uintptr_t* bitset)
+        : c(c),
+          copy(copy),
+          bitset(bitset),
+          first(0),
+          second(0),
+          last(0),
+          visits(0),
+          total(0)
+    {
+    }
 
-      virtual bool visit(unsigned offset) {
-        if (Debug) {
-          fprintf(stderr, "  update %p (%s) at %p - offset %d from %p (%s)\n",
-                  get(copy, offset),
-                  segment(c, get(copy, offset)),
-                  getp(copy, offset),
-                  offset,
-                  copy,
-                  segment(c, copy));
+    virtual bool visit(unsigned offset)
+    {
+      if (Debug) {
+        fprintf(stderr,
+                "  update %p (%s) at %p - offset %d from %p (%s)\n",
+                get(copy, offset),
+                segment(c, get(copy, offset)),
+                getp(copy, offset),
+                offset,
+                copy,
+                segment(c, copy));
+      }
+
+      bool needsVisit;
+      void* childCopy
+          = update(c, getp(copy, offset), copy, offset, &needsVisit);
+
+      if (Debug) {
+        fprintf(stderr,
+                "    result: %p (%s) (visit? %d)\n",
+                childCopy,
+                segment(c, childCopy),
+                needsVisit);
+      }
+
+      ++total;
+
+      if (total == 3) {
+        bitsetInit(bitset);
+      }
+
+      if (needsVisit) {
+        ++visits;
+
+        if (visits == 1) {
+          first = offset;
+        } else if (visits == 2) {
+          second = offset;
         }
+      } else {
+        local::set(copy, offset, childCopy);
+      }
 
-        bool needsVisit;
-        void* childCopy = update
-          (c, getp(copy, offset), copy, offset, &needsVisit);
-        
-        if (Debug) {
-          fprintf(stderr, "    result: %p (%s) (visit? %d)\n",
-                  childCopy, segment(c, childCopy), needsVisit);
-        }
+      if (visits > 1 and total > 2 and (second or needsVisit)) {
+        bitsetClear(bitset, last, offset);
+        last = offset;
 
-        ++ total;
-
-        if (total == 3) {
-          bitsetInit(bitset);
+        if (second) {
+          bitsetSet(bitset, second, true);
+          second = 0;
         }
 
         if (needsVisit) {
-          ++ visits;
-
-          if (visits == 1) {
-            first = offset;
-          } else if (visits == 2) {
-            second = offset;
-          }
-        } else {
-          local::set(copy, offset, childCopy);
+          bitsetSet(bitset, offset, true);
         }
-
-        if (visits > 1 and total > 2 and (second or needsVisit)) {
-          bitsetClear(bitset, last, offset);
-          last = offset;
-
-          if (second) {
-            bitsetSet(bitset, second, true);
-            second = 0;
-          }
-          
-          if (needsVisit) {
-            bitsetSet(bitset, offset, true);
-          }
-        }
-
-        return true;
       }
 
-      Context* c;
-      void* copy;
-      uintptr_t* bitset;
-      unsigned first;
-      unsigned second;
-      unsigned last;
-      unsigned visits;
-      unsigned total;
-    } walker(c, copy, bitset(c, original));
-
-    if (Debug) {
-      fprintf(stderr, "walk %p (%s)\n", copy, segment(c, copy));
+      return true;
     }
 
-    c->client->walk(copy, &walker);
+    Context* c;
+    void* copy;
+    uintptr_t* bitset;
+    unsigned first;
+    unsigned second;
+    unsigned last;
+    unsigned visits;
+    unsigned total;
+  } walker(c, copy, bitset(c, original));
 
-    if (walker.visits) {
-      // descend
-      if (walker.visits > 1) {
-        parent(c, original) = parent_;
-        parent_ = original;
-      }
-
-      original = get(copy, walker.first);
-      local::set(copy, walker.first, follow(c, original));
-      goto visit;
-    } else {
-      // ascend
-      original = parent_;
-    }
+  if (Debug) {
+    fprintf(stderr, "walk %p (%s)\n", copy, segment(c, copy));
   }
 
+  c->client->walk(copy, &walker);
+
+  if (walker.visits) {
+    // descend
+    if (walker.visits > 1) {
+      parent(c, original) = parent_;
+      parent_ = original;
+    }
+
+    original = get(copy, walker.first);
+    local::set(copy, walker.first, follow(c, original));
+    goto visit;
+  } else {
+    // ascend
+    original = parent_;
+  }
+}
+
   if (original) {
     void* copy = follow(c, original);
 
     class Walker : public Heap::Walker {
      public:
-      Walker(Context* c, uintptr_t* bitset):
-        c(c),
-        bitset(bitset),
-        next(0),
-        total(0)
-      { }
+      Walker(Context* c, uintptr_t* bitset)
+          : c(c), bitset(bitset), next(0), total(0)
+      {
+      }
 
-      virtual bool visit(unsigned offset) {
-        switch (++ total) {
+      virtual bool visit(unsigned offset)
+      {
+        switch (++total) {
         case 1:
           return true;
 
         case 2:
           next = offset;
           return true;
-          
+
         case 3:
           next = bitsetNext(c, bitset);
           return false;
@@ -1486,7 +1550,8 @@ collect(Context* c, void** p, void* target, unsigned offset)
     }
 
     if (Debug) {
-      fprintf(stderr, "  next is %p (%s) at %p - offset %d from %p (%s)\n",
+      fprintf(stderr,
+              "  next is %p (%s) at %p - offset %d from %p (%s)\n",
               get(copy, walker.next),
               segment(c, get(copy, walker.next)),
               getp(copy, walker.next),
@@ -1503,20 +1568,17 @@ collect(Context* c, void** p, void* target, unsigned offset)
   }
 }
 
-void
-collect(Context* c, void** p)
+void collect(Context* c, void** p)
 {
   collect(c, p, 0, 0);
 }
 
-void
-collect(Context* c, void* target, unsigned offset)
+void collect(Context* c, void* target, unsigned offset)
 {
   collect(c, getp(target, offset), target, offset);
 }
 
-void
-visitDirtyFixies(Context* c, Fixie** p)
+void visitDirtyFixies(Context* c, Fixie** p)
 {
   while (*p) {
     Fixie* f = *p;
@@ -1534,13 +1596,10 @@ visitDirtyFixies(Context* c, Fixie** p)
       fprintf(stderr, "clean fixie %p\n", f);
     }
 
-    for (; word <= wordLimit and (word < wordLimit or bit < bitLimit);
-         ++ word)
-    {
+    for (; word <= wordLimit and (word < wordLimit or bit < bitLimit); ++word) {
       if (mask[word]) {
         for (; bit < BitsPerWord and (word < wordLimit or bit < bitLimit);
-             ++ bit)
-        {
+             ++bit) {
           unsigned index = indexOf(word, bit);
 
           if (getBit(mask, index)) {
@@ -1549,8 +1608,11 @@ visitDirtyFixies(Context* c, Fixie** p)
             clearBit(mask, index);
 
             if (DebugFixies) {
-              fprintf(stderr, "clean fixie %p at %d (%p)\n",
-                      f, index, f->body() + index);
+              fprintf(stderr,
+                      "clean fixie %p at %d (%p)\n",
+                      f,
+                      index,
+                      f->body() + index);
             }
 
             collect(c, f->body(), index);
@@ -1578,8 +1640,7 @@ visitDirtyFixies(Context* c, Fixie** p)
   }
 }
 
-void
-visitMarkedFixies(Context* c)
+void visitMarkedFixies(Context* c)
 {
   while (c->markedFixies) {
     Fixie* f = c->markedFixies;
@@ -1589,13 +1650,14 @@ visitMarkedFixies(Context* c)
       fprintf(stderr, "visit fixie %p\n", f);
     }
 
-    class Walker: public Heap::Walker {
+    class Walker : public Heap::Walker {
      public:
-      Walker(Context* c, void** p):
-        c(c), p(p)
-      { }
+      Walker(Context* c, void** p) : c(c), p(p)
+      {
+      }
 
-      virtual bool visit(unsigned offset) {
+      virtual bool visit(unsigned offset)
+      {
         local::collect(c, p, offset);
         return true;
       }
@@ -1607,12 +1669,15 @@ visitMarkedFixies(Context* c)
     c->client->walk(f->body(), &w);
 
     f->move(c, &(c->visitedFixies));
-  }  
+  }
 }
 
-void
-collect(Context* c, Segment::Map* map, unsigned start, unsigned end,
-        bool* dirty, bool expectDirty UNUSED)
+void collect(Context* c,
+             Segment::Map* map,
+             unsigned start,
+             unsigned end,
+             bool* dirty,
+             bool expectDirty UNUSED)
 {
   bool wasDirty UNUSED = false;
   for (Segment::Map::Iterator it(map, start, end); it.hasMore();) {
@@ -1651,8 +1716,7 @@ collect(Context* c, Segment::Map* map, unsigned start, unsigned end,
   assertT(c, wasDirty or not expectDirty);
 }
 
-void
-collect2(Context* c)
+void collect2(Context* c)
 {
   c->gen2Base = Top;
   c->tenureFootprint = 0;
@@ -1677,9 +1741,12 @@ collect2(Context* c)
 
   class Visitor : public Heap::Visitor {
    public:
-    Visitor(Context* c): c(c) { }
+    Visitor(Context* c) : c(c)
+    {
+    }
 
-    virtual void visit(void* p) {
+    virtual void visit(void* p)
+    {
       local::collect(c, static_cast<void**>(p));
       visitMarkedFixies(c);
     }
@@ -1690,11 +1757,10 @@ collect2(Context* c)
   c->client->visitRoots(&v);
 }
 
-bool
-limitExceeded(Context* c, int pendingAllocation)
+bool limitExceeded(Context* c, int pendingAllocation)
 {
   unsigned count = c->count + pendingAllocation
-    - (c->gen2.remaining() * BytesPerWord);
+                   - (c->gen2.remaining() * BytesPerWord);
 
   if (Verbose) {
     if (count > c->limit) {
@@ -1704,30 +1770,26 @@ limitExceeded(Context* c, int pendingAllocation)
       }
     } else if (c->limitWasExceeded) {
       c->limitWasExceeded = false;
-      fprintf(stderr, "heap limit %d no longer exceeded: %d\n",
-              c->limit, count);
+      fprintf(
+          stderr, "heap limit %d no longer exceeded: %d\n", c->limit, count);
     }
   }
 
   return count > c->limit;
 }
 
-void
-collect(Context* c)
+void collect(Context* c)
 {
-  if (limitExceeded(c, c->pendingAllocation)
-      or oversizedGen2(c)
+  if (limitExceeded(c, c->pendingAllocation) or oversizedGen2(c)
       or c->tenureFootprint + c->tenurePadding > c->gen2.remaining()
       or c->fixieTenureFootprint + c->tenuredFixieFootprint
-      > c->tenuredFixieCeiling)
-  {
+         > c->tenuredFixieCeiling) {
     if (Verbose) {
       if (limitExceeded(c, c->pendingAllocation)) {
         fprintf(stderr, "low memory causes ");
       } else if (oversizedGen2(c)) {
         fprintf(stderr, "oversized gen2 causes ");
-      } else if (c->tenureFootprint + c->tenurePadding > c->gen2.remaining())
-      {
+      } else if (c->tenureFootprint + c->tenurePadding > c->gen2.remaining()) {
         fprintf(stderr, "undersized gen2 causes ");
       } else {
         fprintf(stderr, "fixie ceiling causes ");
@@ -1801,8 +1863,7 @@ collect(Context* c)
   }
 }
 
-void*
-allocate(Context* c, unsigned size, bool limit)
+void* allocate(Context* c, unsigned size, bool limit)
 {
   ACQUIRE(c->lock);
 
@@ -1814,7 +1875,7 @@ allocate(Context* c, unsigned size, bool limit)
     void* p = c->system->tryAllocate(size);
     if (p) {
       c->count += size;
-      
+
       if (DebugAllocation) {
         static_cast<uintptr_t*>(p)[0] = 0x22377322;
         static_cast<uintptr_t*>(p)[(size / BytesPerWord) - 1] = 0x22377322;
@@ -1827,14 +1888,12 @@ allocate(Context* c, unsigned size, bool limit)
   return 0;
 }
 
-void*
-tryAllocate(Context* c, unsigned size)
+void* tryAllocate(Context* c, unsigned size)
 {
   return allocate(c, size, true);
 }
 
-void*
-allocate(Context* c, unsigned size)
+void* allocate(Context* c, unsigned size)
 {
   void* p = allocate(c, size, false);
   expect(c->system, p);
@@ -1842,8 +1901,7 @@ allocate(Context* c, unsigned size)
   return p;
 }
 
-void
-free(Context* c, const void* p, unsigned size)
+void free(Context* c, const void* p, unsigned size)
 {
   ACQUIRE(c->lock);
 
@@ -1856,8 +1914,9 @@ free(Context* c, const void* p, unsigned size)
 
     expect(c->system, static_cast<const uintptr_t*>(p)[0] == 0x22377322);
 
-    expect(c->system, static_cast<const uintptr_t*>(p)
-           [(size / BytesPerWord) - 1] == 0x22377322);
+    expect(c->system,
+           static_cast<const uintptr_t*>(p)[(size / BytesPerWord) - 1]
+           == 0x22377322);
   }
 
   expect(c->system, c->count >= size);
@@ -1866,53 +1925,61 @@ free(Context* c, const void* p, unsigned size)
   c->count -= size;
 }
 
-void
-free_(Context* c, const void* p, unsigned size)
+void free_(Context* c, const void* p, unsigned size)
 {
   free(c, p, size);
 }
 
-class MyHeap: public Heap {
+class MyHeap : public Heap {
  public:
-  MyHeap(System* system, unsigned limit):
-    c(system, limit)
-  { }
+  MyHeap(System* system, unsigned limit) : c(system, limit)
+  {
+  }
 
-  virtual void setClient(Heap::Client* client) {
+  virtual void setClient(Heap::Client* client)
+  {
     assertT(&c, c.client == 0);
     c.client = client;
   }
 
-  virtual void setImmortalHeap(uintptr_t* start, unsigned sizeInWords) {
+  virtual void setImmortalHeap(uintptr_t* start, unsigned sizeInWords)
+  {
     c.immortalHeapStart = start;
     c.immortalHeapEnd = start + sizeInWords;
   }
 
-  virtual unsigned remaining() {
+  virtual unsigned remaining()
+  {
     return c.limit - c.count;
   }
 
-  virtual unsigned limit() {
+  virtual unsigned limit()
+  {
     return c.limit;
   }
 
-  virtual bool limitExceeded(int pendingAllocation = 0) {
+  virtual bool limitExceeded(int pendingAllocation = 0)
+  {
     return local::limitExceeded(&c, pendingAllocation);
   }
 
-  virtual void* tryAllocate(unsigned size) {
+  virtual void* tryAllocate(unsigned size)
+  {
     return local::tryAllocate(&c, size);
   }
 
-  virtual void* allocate(unsigned size) {
+  virtual void* allocate(unsigned size)
+  {
     return local::allocate(&c, size);
   }
 
-  virtual void free(const void* p, unsigned size) {
+  virtual void free(const void* p, unsigned size)
+  {
     free_(&c, p, size);
   }
 
-  virtual void collect(CollectionType type, unsigned incomingFootprint,
+  virtual void collect(CollectionType type,
+                       unsigned incomingFootprint,
                        int pendingAllocation)
   {
     c.mode = type;
@@ -1922,12 +1989,16 @@ class MyHeap: public Heap {
     local::collect(&c);
   }
 
-  virtual unsigned fixedFootprint(unsigned sizeInWords, bool objectMask) {
+  virtual unsigned fixedFootprint(unsigned sizeInWords, bool objectMask)
+  {
     return Fixie::totalSize(sizeInWords, objectMask);
   }
 
-  void* allocateFixed(Allocator* allocator, unsigned sizeInWords,
-                      bool objectMask, Fixie** handle, bool immortal)
+  void* allocateFixed(Allocator* allocator,
+                      unsigned sizeInWords,
+                      bool objectMask,
+                      Fixie** handle,
+                      bool immortal)
   {
     expect(&c, not limitExceeded());
 
@@ -1937,23 +2008,26 @@ class MyHeap: public Heap {
     expect(&c, not limitExceeded());
 
     return (new (p) Fixie(&c, sizeInWords, objectMask, handle, immortal))
-      ->body();
+        ->body();
   }
 
-  virtual void* allocateFixed(Allocator* allocator, unsigned sizeInWords,
+  virtual void* allocateFixed(Allocator* allocator,
+                              unsigned sizeInWords,
                               bool objectMask)
   {
-    return allocateFixed
-      (allocator, sizeInWords, objectMask, &(c.fixies), false);
+    return allocateFixed(
+        allocator, sizeInWords, objectMask, &(c.fixies), false);
   }
 
   virtual void* allocateImmortalFixed(Allocator* allocator,
-                                      unsigned sizeInWords, bool objectMask)
+                                      unsigned sizeInWords,
+                                      bool objectMask)
   {
     return allocateFixed(allocator, sizeInWords, objectMask, 0, true);
   }
 
-  bool needsMark(void* p) {
+  bool needsMark(void* p)
+  {
     assertT(&c, c.client->isFixed(p) or (not immortalHeapContains(&c, p)));
 
     if (c.client->isFixed(p)) {
@@ -1963,16 +2037,17 @@ class MyHeap: public Heap {
     }
   }
 
-  bool targetNeedsMark(void* target) {
-    return target
-      and not c.gen2.contains(target)
-      and not c.nextGen2.contains(target)
-      and not immortalHeapContains(&c, target)
-      and not (c.client->isFixed(target)
-               and fixie(target)->age >= FixieTenureThreshold);
+  bool targetNeedsMark(void* target)
+  {
+    return target and not c.gen2.contains(target)
+           and not c.nextGen2.contains(target)
+           and not immortalHeapContains(&c, target)
+           and not(c.client->isFixed(target)
+                   and fixie(target)->age >= FixieTenureThreshold);
   }
 
-  virtual void mark(void* p, unsigned offset, unsigned count) {
+  virtual void mark(void* p, unsigned offset, unsigned count)
+  {
     if (needsMark(p)) {
 #ifndef USE_ATOMIC_OPERATIONS
       ACQUIRE(c.lock);
@@ -1987,8 +2062,12 @@ class MyHeap: public Heap {
           void** target = static_cast<void**>(p) + offset + i;
           if (targetNeedsMark(maskAlignedPointer(*target))) {
             if (DebugFixies) {
-              fprintf(stderr, "dirty fixie %p at %d (%p): %p\n",
-                      f, offset, f->body() + offset, maskAlignedPointer(*target));
+              fprintf(stderr,
+                      "dirty fixie %p at %d (%p): %p\n",
+                      f,
+                      offset,
+                      f->body() + offset,
+                      maskAlignedPointer(*target));
             }
 
             dirty = true;
@@ -2001,7 +2080,8 @@ class MyHeap: public Heap {
           }
         }
 
-        if (dirty) markDirty(&c, f);
+        if (dirty)
+          markDirty(&c, f);
       } else {
         Segment::Map* map;
         if (c.gen2.contains(p)) {
@@ -2025,28 +2105,33 @@ class MyHeap: public Heap {
     }
   }
 
-  virtual void pad(void* p) {
+  virtual void pad(void* p)
+  {
     if (c.gen1.contains(p)) {
       if (c.ageMap.get(p) == TenureThreshold) {
-        ++ c.tenurePadding;
+        ++c.tenurePadding;
       } else {
-        ++ c.gen1Padding;
+        ++c.gen1Padding;
       }
     } else if (c.gen2.contains(p)) {
-      ++ c.gen2Padding;
+      ++c.gen2Padding;
     } else {
-      ++ c.gen1Padding;
+      ++c.gen1Padding;
     }
   }
 
-  virtual void* follow(void* p) {
+  virtual void* follow(void* p)
+  {
     if (p == 0 or c.client->isFixed(p)) {
       return p;
     } else if (wasCollected(&c, p)) {
       if (Debug) {
-        fprintf(stderr, "follow %p (%s) to %p (%s)\n",
-                p, segment(&c, p),
-                local::follow(&c, p), segment(&c, local::follow(&c, p)));
+        fprintf(stderr,
+                "follow %p (%s) to %p (%s)\n",
+                p,
+                segment(&c, p),
+                local::follow(&c, p),
+                segment(&c, local::follow(&c, p)));
       }
 
       return local::follow(&c, p);
@@ -2055,30 +2140,29 @@ class MyHeap: public Heap {
     }
   }
 
-  virtual void postVisit() {
+  virtual void postVisit()
+  {
     killFixies(&c);
   }
 
-  virtual Status status(void* p) {
+  virtual Status status(void* p)
+  {
     p = maskAlignedPointer(p);
 
     if (p == 0) {
       return Null;
     } else if (c.client->isFixed(p)) {
       Fixie* f = fixie(p);
-      return f->dead()
-        ? Unreachable
-        : (static_cast<unsigned>(f->age + 1) < FixieTenureThreshold
-           ? Reachable
-           : Tenured);
+      return f->dead() ? Unreachable : (static_cast<unsigned>(f->age + 1)
+                                            < FixieTenureThreshold
+                                            ? Reachable
+                                            : Tenured);
     } else if (c.nextGen1.contains(p)) {
       return Reachable;
-    } else if (c.nextGen2.contains(p)
-               or immortalHeapContains(&c, p)
+    } else if (c.nextGen2.contains(p) or immortalHeapContains(&c, p)
                or (c.gen2.contains(p)
                    and (c.mode == Heap::MinorCollection
-                        or c.gen2.indexOf(p) >= c.gen2Base)))
-    {
+                        or c.gen2.indexOf(p) >= c.gen2Base))) {
       return Tenured;
     } else if (wasCollected(&c, p)) {
       return Reachable;
@@ -2087,15 +2171,18 @@ class MyHeap: public Heap {
     }
   }
 
-  virtual CollectionType collectionType() {
+  virtual CollectionType collectionType()
+  {
     return c.mode;
   }
 
-  virtual void disposeFixies() {
+  virtual void disposeFixies()
+  {
     c.disposeFixies();
   }
 
-  virtual void dispose() {
+  virtual void dispose()
+  {
     c.dispose();
     assertT(&c, c.count == 0);
     c.system->free(this);
@@ -2104,17 +2191,16 @@ class MyHeap: public Heap {
   Context c;
 };
 
-} // namespace local
+}  // namespace local
 
-} // namespace
+}  // namespace
 
 namespace vm {
 
-Heap*
-makeHeap(System* system, unsigned limit)
-{  
+Heap* makeHeap(System* system, unsigned limit)
+{
   return new (system->tryAllocate(sizeof(local::MyHeap)))
-    local::MyHeap(system, limit);
+      local::MyHeap(system, limit);
 }
 
-} // namespace vm
+}  // namespace vm
diff --git a/src/heapdump.cpp b/src/heapdump.cpp
index 80c4522ef9..f729c10ef5 100644
--- a/src/heapdump.cpp
+++ b/src/heapdump.cpp
@@ -17,62 +17,55 @@ namespace {
 
 namespace local {
 
-enum {
-  Root,
-  Size,
-  ClassName,
-  Push,
-  Pop
-};
+enum { Root, Size, ClassName, Push, Pop };
 
-void
-write1(FILE* out, uint8_t v)
+void write1(FILE* out, uint8_t v)
 {
   size_t n UNUSED = fwrite(&v, 1, 1, out);
 }
 
-void
-write4(FILE* out, uint32_t v)
+void write4(FILE* out, uint32_t v)
 {
-  uint8_t b[] = { static_cast<uint8_t>( v >> 24        ),
-                  static_cast<uint8_t>((v >> 16) & 0xFF),
-                  static_cast<uint8_t>((v >>  8) & 0xFF),
-                  static_cast<uint8_t>( v        & 0xFF) };
+  uint8_t b[] = {static_cast<uint8_t>(v >> 24),
+                 static_cast<uint8_t>((v >> 16) & 0xFF),
+                 static_cast<uint8_t>((v >> 8) & 0xFF),
+                 static_cast<uint8_t>(v & 0xFF)};
 
   size_t n UNUSED = fwrite(b, 4, 1, out);
 }
 
-void
-writeString(FILE* out, int8_t* p, unsigned size)
+void writeString(FILE* out, int8_t* p, unsigned size)
 {
   write4(out, size);
   size_t n UNUSED = fwrite(p, size, 1, out);
 }
 
-unsigned
-objectSize(Thread* t, object o)
+unsigned objectSize(Thread* t, object o)
 {
   return extendedSize(t, o, baseSize(t, o, objectClass(t, o)));
 }
 
-} // namespace local
+}  // namespace local
 
-} // namespace
+}  // namespace
 
 namespace vm {
 
-void
-dumpHeap(Thread* t, FILE* out)
+void dumpHeap(Thread* t, FILE* out)
 {
-  class Visitor: public HeapVisitor {
+  class Visitor : public HeapVisitor {
    public:
-    Visitor(Thread* t, FILE* out): t(t), out(out), nextNumber(1) { }
-
-    virtual void root() {
-      write1(out, local::Root);      
+    Visitor(Thread* t, FILE* out) : t(t), out(out), nextNumber(1)
+    {
     }
 
-    virtual unsigned visitNew(object p) {
+    virtual void root()
+    {
+      write1(out, local::Root);
+    }
+
+    virtual unsigned visitNew(object p)
+    {
       if (p) {
         unsigned number = nextNumber++;
         local::write4(out, number);
@@ -84,8 +77,8 @@ dumpHeap(Thread* t, FILE* out)
           object name = className(t, p);
           if (name) {
             local::write1(out, local::ClassName);
-            local::writeString(out, &byteArrayBody(t, name, 0),
-                               byteArrayLength(t, name) - 1);
+            local::writeString(
+                out, &byteArrayBody(t, name, 0), byteArrayLength(t, name) - 1);
           }
         }
 
@@ -95,15 +88,18 @@ dumpHeap(Thread* t, FILE* out)
       }
     }
 
-    virtual void visitOld(object, unsigned number) {
-      local::write4(out, number);      
+    virtual void visitOld(object, unsigned number)
+    {
+      local::write4(out, number);
     }
 
-    virtual void push(object, unsigned, unsigned) {
+    virtual void push(object, unsigned, unsigned)
+    {
       local::write1(out, local::Push);
     }
 
-    virtual void pop() {
+    virtual void pop()
+    {
       local::write1(out, local::Pop);
     }
 
@@ -117,4 +113,4 @@ dumpHeap(Thread* t, FILE* out)
   w->dispose();
 }
 
-} // namespace vm
+}  // namespace vm
diff --git a/src/heapwalk.cpp b/src/heapwalk.cpp
index b086245ab9..4aca3259d5 100644
--- a/src/heapwalk.cpp
+++ b/src/heapwalk.cpp
@@ -21,7 +21,7 @@ const uintptr_t PointerShift = log(BytesPerWord);
 
 class Context;
 
-class Set: public HeapMap {
+class Set : public HeapMap {
  public:
   class Entry {
    public:
@@ -30,23 +30,22 @@ class Set: public HeapMap {
     int next;
   };
 
-  static unsigned footprint(unsigned capacity) {
-    return sizeof(Set)
-      + pad(sizeof(int) * capacity)
-      + pad(sizeof(Set::Entry) * capacity);
+  static unsigned footprint(unsigned capacity)
+  {
+    return sizeof(Set) + pad(sizeof(int) * capacity)
+           + pad(sizeof(Set::Entry) * capacity);
   }
 
-  Set(Context* context, unsigned capacity):
-    context(context),
-    index(reinterpret_cast<int*>
-          (reinterpret_cast<uint8_t*>(this)
-           + sizeof(Set))),
-    entries(reinterpret_cast<Entry*>
-            (reinterpret_cast<uint8_t*>(index) 
-             + pad(sizeof(int) * capacity))),
-    size(0),
-    capacity(capacity)
-  { }
+  Set(Context* context, unsigned capacity)
+      : context(context),
+        index(reinterpret_cast<int*>(reinterpret_cast<uint8_t*>(this)
+                                     + sizeof(Set))),
+        entries(reinterpret_cast<Entry*>(reinterpret_cast<uint8_t*>(index)
+                                         + pad(sizeof(int) * capacity))),
+        size(0),
+        capacity(capacity)
+  {
+  }
 
   virtual int find(object value);
 
@@ -69,7 +68,9 @@ class Stack {
 
   static const unsigned Capacity = 4096;
 
-  Stack(Stack* next): next(next), entryCount(0) { }
+  Stack(Stack* next) : next(next), entryCount(0)
+  {
+  }
 
   Stack* next;
   unsigned entryCount;
@@ -78,11 +79,12 @@ class Stack {
 
 class Context {
  public:
-  Context(Thread* thread):
-    thread(thread), objects(0), stack(0)
-  { }
+  Context(Thread* thread) : thread(thread), objects(0), stack(0)
+  {
+  }
 
-  void dispose() {
+  void dispose()
+  {
     if (objects) {
       objects->dispose();
     }
@@ -99,20 +101,18 @@ class Context {
   Stack* stack;
 };
 
-void
-push(Context* c, object p, int offset)
+void push(Context* c, object p, int offset)
 {
   if (c->stack == 0 or c->stack->entryCount == Stack::Capacity) {
     c->stack = new (c->thread->m->heap->allocate(sizeof(Stack)))
-      Stack(c->stack);
+        Stack(c->stack);
   }
   Stack::Entry* e = c->stack->entries + (c->stack->entryCount++);
   e->value = p;
   e->offset = offset;
 }
 
-bool
-pop(Context* c, object* p, int* offset)
+bool pop(Context* c, object* p, int* offset)
 {
   if (c->stack) {
     if (c->stack->entryCount == 0) {
@@ -133,17 +133,15 @@ pop(Context* c, object* p, int* offset)
   }
 }
 
-unsigned
-hash(object p, unsigned capacity)
+unsigned hash(object p, unsigned capacity)
 {
-  return (reinterpret_cast<uintptr_t>(p) >> PointerShift)
-    & (capacity - 1);
+  return (reinterpret_cast<uintptr_t>(p) >> PointerShift) & (capacity - 1);
 }
 
-Set::Entry*
-find(Context* c, object p)
+Set::Entry* find(Context* c, object p)
 {
-  if (c->objects == 0) return 0;
+  if (c->objects == 0)
+    return 0;
 
   for (int i = c->objects->index[hash(p, c->objects->capacity)]; i >= 0;) {
     Set::Entry* e = c->objects->entries + i;
@@ -156,8 +154,7 @@ find(Context* c, object p)
   return 0;
 }
 
-int
-Set::find(object value)
+int Set::find(object value)
 {
   Set::Entry* e = local::find(context, value);
   if (e) {
@@ -167,14 +164,12 @@ Set::find(object value)
   }
 }
 
-void
-Set::dispose()
+void Set::dispose()
 {
   context->thread->m->heap->free(this, footprint(capacity));
 }
 
-Set::Entry*
-add(Context* c UNUSED, Set* set, object p, uint32_t number)
+Set::Entry* add(Context* c UNUSED, Set* set, object p, uint32_t number)
 {
   assertT(c->thread, set->size < set->capacity);
 
@@ -189,19 +184,18 @@ add(Context* c UNUSED, Set* set, object p, uint32_t number)
   return e;
 }
 
-Set::Entry*
-add(Context* c, object p)
+Set::Entry* add(Context* c, object p)
 {
   if (c->objects == 0 or c->objects->size == c->objects->capacity) {
     unsigned capacity;
     if (c->objects) {
       capacity = c->objects->capacity * 2;
     } else {
-      capacity = 4096; // must be power of two
+      capacity = 4096;  // must be power of two
     }
 
     Set* set = new (c->thread->m->heap->allocate(Set::footprint(capacity)))
-      Set(c, capacity);
+        Set(c, capacity);
 
     memset(set->index, 0xFF, sizeof(int) * capacity);
 
@@ -214,8 +208,8 @@ add(Context* c, object p)
         }
       }
 
-      c->thread->m->heap->free
-        (c->objects, Set::footprint(c->objects->capacity));
+      c->thread->m->heap->free(c->objects,
+                               Set::footprint(c->objects->capacity));
     }
 
     c->objects = set;
@@ -224,16 +218,13 @@ add(Context* c, object p)
   return add(c, c->objects, p, 0);
 }
 
-inline object
-get(object o, unsigned offsetInWords)
+inline object get(object o, unsigned offsetInWords)
 {
-  return static_cast<object>
-    (maskAlignedPointer
-     (fieldAtOffset<void*>(o, offsetInWords * BytesPerWord)));
+  return static_cast<object>(maskAlignedPointer(
+      fieldAtOffset<void*>(o, offsetInWords * BytesPerWord)));
 }
 
-unsigned
-walk(Context* c, HeapVisitor* v, object p)
+unsigned walk(Context* c, HeapVisitor* v, object p)
 {
   Thread* t = c->thread;
   object root = p;
@@ -241,65 +232,70 @@ walk(Context* c, HeapVisitor* v, object p)
 
   v->root();
 
- visit: {
-    Set::Entry* e = find(c, p);
-    if (e) {
-      v->visitOld(p, e->number);
-    } else {
-      e = add(c, p);
-      e->number = v->visitNew(p);
+visit : {
+  Set::Entry* e = find(c, p);
+  if (e) {
+    v->visitOld(p, e->number);
+  } else {
+    e = add(c, p);
+    e->number = v->visitNew(p);
 
-      nextChildOffset = walkNext(t, p, -1);
-      if (nextChildOffset != -1) {
-        goto children;
-      }
+    nextChildOffset = walkNext(t, p, -1);
+    if (nextChildOffset != -1) {
+      goto children;
     }
   }
+}
 
   goto pop;
 
- children: {
-    v->push(p, find(c, p)->number, nextChildOffset);
-    push(c, p, nextChildOffset);
-    p = get(p, nextChildOffset);
-    goto visit;
-  }
+children : {
+  v->push(p, find(c, p)->number, nextChildOffset);
+  push(c, p, nextChildOffset);
+  p = get(p, nextChildOffset);
+  goto visit;
+}
 
- pop: {
-    if (pop(c, &p, &nextChildOffset)) {
-      v->pop();
-      nextChildOffset = walkNext(t, p, nextChildOffset);
-      if (nextChildOffset >= 0) {
-        goto children;
-      } else {
-        goto pop;
-      }
+pop : {
+  if (pop(c, &p, &nextChildOffset)) {
+    v->pop();
+    nextChildOffset = walkNext(t, p, nextChildOffset);
+    if (nextChildOffset >= 0) {
+      goto children;
+    } else {
+      goto pop;
     }
   }
+}
 
   return find(c, root)->number;
 }
 
-class MyHeapWalker: public HeapWalker {
+class MyHeapWalker : public HeapWalker {
  public:
-  MyHeapWalker(Thread* t, HeapVisitor* v):
-    context(t), visitor(v)
+  MyHeapWalker(Thread* t, HeapVisitor* v) : context(t), visitor(v)
   {
     add(&context, 0)->number = v->visitNew(0);
   }
 
-  virtual unsigned visitRoot(object root) {
+  virtual unsigned visitRoot(object root)
+  {
     return walk(&context, visitor, root);
   }
 
-  virtual void visitAllRoots() {
-    class Visitor: public Heap::Visitor {
+  virtual void visitAllRoots()
+  {
+    class Visitor : public Heap::Visitor {
      public:
-      Visitor(Context* c, HeapVisitor* v): c(c), v(v) { }
+      Visitor(Context* c, HeapVisitor* v) : c(c), v(v)
+      {
+      }
 
-      virtual void visit(void* p) {
-        walk(c, v, static_cast<object>
-             (maskAlignedPointer(*static_cast<void**>(p))));
+      virtual void visit(void* p)
+      {
+        walk(c,
+             v,
+             static_cast<object>(maskAlignedPointer(*static_cast<void**>(p))));
       }
 
       Context* c;
@@ -309,11 +305,13 @@ class MyHeapWalker: public HeapWalker {
     visitRoots(context.thread->m, &v);
   }
 
-  virtual HeapMap* map() {
+  virtual HeapMap* map()
+  {
     return context.objects;
   }
 
-  virtual void dispose() {
+  virtual void dispose()
+  {
     context.dispose();
     context.thread->m->heap->free(this, sizeof(MyHeapWalker));
   }
@@ -322,17 +320,16 @@ class MyHeapWalker: public HeapWalker {
   HeapVisitor* visitor;
 };
 
-} // namespace local
+}  // namespace local
 
-} // namespace
+}  // namespace
 
 namespace vm {
 
-HeapWalker*
-makeHeapWalker(Thread* t, HeapVisitor* v)
+HeapWalker* makeHeapWalker(Thread* t, HeapVisitor* v)
 {
   return new (t->m->heap->allocate(sizeof(local::MyHeapWalker)))
-    local::MyHeapWalker(t, v);
+      local::MyHeapWalker(t, v);
 }
 
-} // namespace vm
+}  // namespace vm
diff --git a/src/interpret.cpp b/src/interpret.cpp
index c8cdeec2c2..b1f5a648fe 100644
--- a/src/interpret.cpp
+++ b/src/interpret.cpp
@@ -32,7 +32,7 @@ const unsigned FrameMethodOffset = 2;
 const unsigned FrameIpOffset = 3;
 const unsigned FrameFootprint = 4;
 
-class Thread: public vm::Thread {
+class Thread : public vm::Thread {
  public:
   Thread(Machine* m, GcThread* javaThread, vm::Thread* parent)
       : vm::Thread(m, javaThread, parent),
@@ -41,7 +41,8 @@ class Thread: public vm::Thread {
         frame(-1),
         code(0),
         stackPointers(0)
-  { }
+  {
+  }
 
   unsigned ip;
   unsigned sp;
@@ -51,40 +52,36 @@ class Thread: public vm::Thread {
   uintptr_t stack[0];
 };
 
-inline void
-pushObject(Thread* t, object o)
+inline void pushObject(Thread* t, object o)
 {
   if (DebugStack) {
     fprintf(stderr, "push object %p at %d\n", o, t->sp);
   }
 
   assertT(t, t->sp + 1 < stackSizeInWords(t) / 2);
-  t->stack[(t->sp * 2)    ] = ObjectTag;
+  t->stack[(t->sp * 2)] = ObjectTag;
   t->stack[(t->sp * 2) + 1] = reinterpret_cast<uintptr_t>(o);
-  ++ t->sp;
+  ++t->sp;
 }
 
-inline void
-pushInt(Thread* t, uint32_t v)
+inline void pushInt(Thread* t, uint32_t v)
 {
   if (DebugStack) {
     fprintf(stderr, "push int %d at %d\n", v, t->sp);
   }
 
   assertT(t, t->sp + 1 < stackSizeInWords(t) / 2);
-  t->stack[(t->sp * 2)    ] = IntTag;
+  t->stack[(t->sp * 2)] = IntTag;
   t->stack[(t->sp * 2) + 1] = v;
-  ++ t->sp;
+  ++t->sp;
 }
 
-inline void
-pushFloat(Thread* t, float v)
+inline void pushFloat(Thread* t, float v)
 {
   pushInt(t, floatToBits(v));
 }
 
-inline void
-pushLong(Thread* t, uint64_t v)
+inline void pushLong(Thread* t, uint64_t v)
 {
   if (DebugStack) {
     fprintf(stderr, "push long %" LLD " at %d\n", v, t->sp);
@@ -94,50 +91,48 @@ pushLong(Thread* t, uint64_t v)
   pushInt(t, v & 0xFFFFFFFF);
 }
 
-inline void
-pushDouble(Thread* t, double v)
+inline void pushDouble(Thread* t, double v)
 {
   uint64_t w = doubleToBits(v);
   pushLong(t, w);
 }
 
-inline object
-popObject(Thread* t)
+inline object popObject(Thread* t)
 {
   if (DebugStack) {
-    fprintf(stderr, "pop object %p at %d\n",
+    fprintf(stderr,
+            "pop object %p at %d\n",
             reinterpret_cast<object>(t->stack[((t->sp - 1) * 2) + 1]),
             t->sp - 1);
   }
 
   assertT(t, t->stack[(t->sp - 1) * 2] == ObjectTag);
-  return reinterpret_cast<object>(t->stack[((-- t->sp) * 2) + 1]);
+  return reinterpret_cast<object>(t->stack[((--t->sp) * 2) + 1]);
 }
 
-inline uint32_t
-popInt(Thread* t)
+inline uint32_t popInt(Thread* t)
 {
   if (DebugStack) {
-    fprintf(stderr, "pop int %" ULD " at %d\n",
+    fprintf(stderr,
+            "pop int %" ULD " at %d\n",
             t->stack[((t->sp - 1) * 2) + 1],
             t->sp - 1);
   }
 
   assertT(t, t->stack[(t->sp - 1) * 2] == IntTag);
-  return t->stack[((-- t->sp) * 2) + 1];
+  return t->stack[((--t->sp) * 2) + 1];
 }
 
-inline float
-popFloat(Thread* t)
+inline float popFloat(Thread* t)
 {
   return bitsToFloat(popInt(t));
 }
 
-inline uint64_t
-popLong(Thread* t)
+inline uint64_t popLong(Thread* t)
 {
   if (DebugStack) {
-    fprintf(stderr, "pop long %" LLD " at %d\n",
+    fprintf(stderr,
+            "pop long %" LLD " at %d\n",
             (static_cast<uint64_t>(t->stack[((t->sp - 2) * 2) + 1]) << 32)
             | static_cast<uint64_t>(t->stack[((t->sp - 1) * 2) + 1]),
             t->sp - 2);
@@ -148,18 +143,17 @@ popLong(Thread* t)
   return (b << 32) | a;
 }
 
-inline double
-popDouble(Thread* t)
+inline double popDouble(Thread* t)
 {
   uint64_t v = popLong(t);
   return bitsToDouble(v);
 }
 
-inline object
-peekObject(Thread* t, unsigned index)
+inline object peekObject(Thread* t, unsigned index)
 {
   if (DebugStack) {
-    fprintf(stderr, "peek object %p at %d\n",
+    fprintf(stderr,
+            "peek object %p at %d\n",
             reinterpret_cast<object>(t->stack[(index * 2) + 1]),
             index);
   }
@@ -169,13 +163,11 @@ peekObject(Thread* t, unsigned index)
   return reinterpret_cast<object>(t->stack[(index * 2) + 1]);
 }
 
-inline uint32_t
-peekInt(Thread* t, unsigned index)
+inline uint32_t peekInt(Thread* t, unsigned index)
 {
   if (DebugStack) {
-    fprintf(stderr, "peek int %" ULD " at %d\n",
-            t->stack[(index * 2) + 1],
-            index);
+    fprintf(
+        stderr, "peek int %" ULD " at %d\n", t->stack[(index * 2) + 1], index);
   }
 
   assertT(t, index < stackSizeInWords(t) / 2);
@@ -183,22 +175,21 @@ peekInt(Thread* t, unsigned index)
   return t->stack[(index * 2) + 1];
 }
 
-inline uint64_t
-peekLong(Thread* t, unsigned index)
+inline uint64_t peekLong(Thread* t, unsigned index)
 {
   if (DebugStack) {
-    fprintf(stderr, "peek long %" LLD " at %d\n",
+    fprintf(stderr,
+            "peek long %" LLD " at %d\n",
             (static_cast<uint64_t>(t->stack[(index * 2) + 1]) << 32)
             | static_cast<uint64_t>(t->stack[((index + 1) * 2) + 1]),
             index);
   }
 
   return (static_cast<uint64_t>(peekInt(t, index)) << 32)
-    | static_cast<uint64_t>(peekInt(t, index + 1));
+         | static_cast<uint64_t>(peekInt(t, index + 1));
 }
 
-inline void
-pokeObject(Thread* t, unsigned index, object value)
+inline void pokeObject(Thread* t, unsigned index, object value)
 {
   if (DebugStack) {
     fprintf(stderr, "poke object %p at %d\n", value, index);
@@ -208,8 +199,7 @@ pokeObject(Thread* t, unsigned index, object value)
   t->stack[(index * 2) + 1] = reinterpret_cast<uintptr_t>(value);
 }
 
-inline void
-pokeInt(Thread* t, unsigned index, uint32_t value)
+inline void pokeInt(Thread* t, unsigned index, uint32_t value)
 {
   if (DebugStack) {
     fprintf(stderr, "poke int %d at %d\n", value, index);
@@ -219,8 +209,7 @@ pokeInt(Thread* t, unsigned index, uint32_t value)
   t->stack[(index * 2) + 1] = value;
 }
 
-inline void
-pokeLong(Thread* t, unsigned index, uint64_t value)
+inline void pokeLong(Thread* t, unsigned index, uint64_t value)
 {
   if (DebugStack) {
     fprintf(stderr, "poke long %" LLD " at %d\n", value, index);
@@ -230,8 +219,7 @@ pokeLong(Thread* t, unsigned index, uint64_t value)
   pokeInt(t, index + 1, value & 0xFFFFFFFF);
 }
 
-inline object*
-pushReference(Thread* t, object o)
+inline object* pushReference(Thread* t, object o)
 {
   if (o) {
     expect(t, t->sp + 1 < stackSizeInWords(t) / 2);
@@ -242,8 +230,7 @@ pushReference(Thread* t, object o)
   }
 }
 
-inline int
-frameNext(Thread* t, int frame)
+inline int frameNext(Thread* t, int frame)
 {
   return peekInt(t, frame + FrameNextOffset);
 }
@@ -253,50 +240,42 @@ inline GcMethod* frameMethod(Thread* t, int frame)
   return cast<GcMethod>(t, peekObject(t, frame + FrameMethodOffset));
 }
 
-inline unsigned
-frameIp(Thread* t, int frame)
+inline unsigned frameIp(Thread* t, int frame)
 {
   return peekInt(t, frame + FrameIpOffset);
 }
 
-inline unsigned
-frameBase(Thread* t, int frame)
+inline unsigned frameBase(Thread* t, int frame)
 {
   return peekInt(t, frame + FrameBaseOffset);
 }
 
-inline object
-localObject(Thread* t, unsigned index)
+inline object localObject(Thread* t, unsigned index)
 {
   return peekObject(t, frameBase(t, t->frame) + index);
 }
 
-inline uint32_t
-localInt(Thread* t, unsigned index)
+inline uint32_t localInt(Thread* t, unsigned index)
 {
   return peekInt(t, frameBase(t, t->frame) + index);
 }
 
-inline uint64_t
-localLong(Thread* t, unsigned index)
+inline uint64_t localLong(Thread* t, unsigned index)
 {
   return peekLong(t, frameBase(t, t->frame) + index);
 }
 
-inline void
-setLocalObject(Thread* t, unsigned index, object value)
+inline void setLocalObject(Thread* t, unsigned index, object value)
 {
   pokeObject(t, frameBase(t, t->frame) + index, value);
 }
 
-inline void
-setLocalInt(Thread* t, unsigned index, uint32_t value)
+inline void setLocalInt(Thread* t, unsigned index, uint32_t value)
 {
   pokeInt(t, frameBase(t, t->frame) + index, value);
 }
 
-inline void
-setLocalLong(Thread* t, unsigned index, uint64_t value)
+inline void setLocalLong(Thread* t, unsigned index, uint64_t value)
 {
   pokeLong(t, frameBase(t, t->frame) + index, value);
 }
@@ -331,7 +310,8 @@ void pushFrame(Thread* t, GcMethod* method)
 
     locals = t->code->maxLocals();
 
-    memset(t->stack + ((base + parameterFootprint) * 2), 0,
+    memset(t->stack + ((base + parameterFootprint) * 2),
+           0,
            (locals - parameterFootprint) * BytesPerWord * 2);
   }
 
@@ -346,8 +326,7 @@ void pushFrame(Thread* t, GcMethod* method)
   pokeInt(t, t->frame + FrameIpOffset, 0);
 }
 
-void
-popFrame(Thread* t)
+void popFrame(Thread* t)
 {
   GcMethod* method = frameMethod(t, t->frame);
 
@@ -370,11 +349,14 @@ popFrame(Thread* t)
   }
 }
 
-class MyStackWalker: public Processor::StackWalker {
+class MyStackWalker : public Processor::StackWalker {
  public:
-  MyStackWalker(Thread* t, int frame): t(t), frame(frame) { }
+  MyStackWalker(Thread* t, int frame) : t(t), frame(frame)
+  {
+  }
 
-  virtual void walk(Processor::StackVisitor* v) {
+  virtual void walk(Processor::StackVisitor* v)
+  {
     for (int frame = this->frame; frame >= 0; frame = frameNext(t, frame)) {
       MyStackWalker walker(t, frame);
       if (not v->visit(&walker)) {
@@ -388,14 +370,16 @@ class MyStackWalker: public Processor::StackWalker {
     return frameMethod(t, frame);
   }
 
-  virtual int ip() {
+  virtual int ip()
+  {
     return frameIp(t, frame);
   }
 
-  virtual unsigned count() {
+  virtual unsigned count()
+  {
     unsigned count = 0;
     for (int frame = this->frame; frame >= 0; frame = frameNext(t, frame)) {
-      ++ count;
+      ++count;
     }
     return count;
   }
@@ -413,8 +397,7 @@ inline void checkStack(Thread* t, GcMethod* method)
   }
 }
 
-void
-pushResult(Thread* t, unsigned returnCode, uint64_t result, bool indirect)
+void pushResult(Thread* t, unsigned returnCode, uint64_t result, bool indirect)
 {
   switch (returnCode) {
   case ByteField:
@@ -458,13 +441,19 @@ pushResult(Thread* t, unsigned returnCode, uint64_t result, bool indirect)
   case ObjectField:
     if (indirect) {
       if (DebugRun) {
-        fprintf(stderr, "result: %p at %p\n",
-                static_cast<uintptr_t>(result) == 0 ? 0 :
-                *reinterpret_cast<object*>(static_cast<uintptr_t>(result)),
-                reinterpret_cast<object*>(static_cast<uintptr_t>(result)));
+        fprintf(
+            stderr,
+            "result: %p at %p\n",
+            static_cast<uintptr_t>(result) == 0
+                ? 0
+                : *reinterpret_cast<object*>(static_cast<uintptr_t>(result)),
+            reinterpret_cast<object*>(static_cast<uintptr_t>(result)));
       }
-      pushObject(t, static_cast<uintptr_t>(result) == 0 ? 0 :
-                 *reinterpret_cast<object*>(static_cast<uintptr_t>(result)));
+      pushObject(
+          t,
+          static_cast<uintptr_t>(result) == 0
+              ? 0
+              : *reinterpret_cast<object*>(static_cast<uintptr_t>(result)));
     } else {
       if (DebugRun) {
         fprintf(stderr, "result: %p\n", reinterpret_cast<object>(result));
@@ -528,7 +517,8 @@ void marshalArguments(Thread* t,
       }
     } break;
 
-    default: abort(t);
+    default:
+      abort(t);
     }
   }
 }
@@ -541,7 +531,7 @@ unsigned invokeNativeSlow(Thread* t, GcMethod* method, void* function)
 
   unsigned footprint = method->parameterFootprint() + 1;
   if (method->flags() & ACC_STATIC) {
-    ++ footprint;
+    ++footprint;
   }
   unsigned count = method->parameterCount() + 2;
 
@@ -561,7 +551,7 @@ unsigned invokeNativeSlow(Thread* t, GcMethod* method, void* function)
     sp = frameBase(t, t->frame);
     jclass = getJClass(t, method->class_());
     RUNTIME_ARRAY_BODY(args)[argOffset++]
-      = reinterpret_cast<uintptr_t>(&jclass);
+        = reinterpret_cast<uintptr_t>(&jclass);
   } else {
     sp = frameBase(t, t->frame);
     object* v = reinterpret_cast<object*>(t->stack + ((sp++) * 2) + 1);
@@ -572,9 +562,12 @@ unsigned invokeNativeSlow(Thread* t, GcMethod* method, void* function)
   }
   RUNTIME_ARRAY_BODY(types)[typeOffset++] = POINTER_TYPE;
 
-  marshalArguments
-    (t, RUNTIME_ARRAY_BODY(args) + argOffset,
-     RUNTIME_ARRAY_BODY(types) + typeOffset, sp, method, false);
+  marshalArguments(t,
+                   RUNTIME_ARRAY_BODY(args) + argOffset,
+                   RUNTIME_ARRAY_BODY(types) + typeOffset,
+                   sp,
+                   method,
+                   false);
 
   unsigned returnCode = method->returnCode();
   unsigned returnType = fieldType(t, returnCode);
@@ -587,7 +580,8 @@ unsigned invokeNativeSlow(Thread* t, GcMethod* method, void* function)
             method->name()->body().begin());
   }
 
-  { ENTER(t, Thread::IdleState);
+  {
+    ENTER(t, Thread::IdleState);
 
     bool noThrow = t->checkpoint->noThrow;
     t->checkpoint->noThrow = true;
@@ -632,7 +626,8 @@ unsigned invokeNative(Thread* t, GcMethod* method)
     pushFrame(t, method);
 
     uint64_t result;
-    { THREAD_RESOURCE0(t, popFrame(static_cast<Thread*>(t)));
+    {
+      THREAD_RESOURCE0(t, popFrame(static_cast<Thread*>(t)));
 
       unsigned footprint = method->parameterFootprint();
       THREAD_RUNTIME_ARRAY(t, uintptr_t, args, footprint);
@@ -640,11 +635,11 @@ unsigned invokeNative(Thread* t, GcMethod* method)
       unsigned argOffset = 0;
       if ((method->flags() & ACC_STATIC) == 0) {
         RUNTIME_ARRAY_BODY(args)[argOffset++]
-          = reinterpret_cast<uintptr_t>(peekObject(t, sp++));
+            = reinterpret_cast<uintptr_t>(peekObject(t, sp++));
       }
 
-      marshalArguments
-        (t, RUNTIME_ARRAY_BODY(args) + argOffset, 0, sp, method, true);
+      marshalArguments(
+          t, RUNTIME_ARRAY_BODY(args) + argOffset, 0, sp, method, true);
 
       result = reinterpret_cast<FastNativeFunction>(native->function())(
           t, method, RUNTIME_ARRAY_BODY(args));
@@ -658,22 +653,19 @@ unsigned invokeNative(Thread* t, GcMethod* method)
   }
 }
 
-inline void
-store(Thread* t, unsigned index)
+inline void store(Thread* t, unsigned index)
 {
   memcpy(t->stack + ((frameBase(t, t->frame) + index) * 2),
-         t->stack + ((-- t->sp) * 2),
+         t->stack + ((--t->sp) * 2),
          BytesPerWord * 2);
 }
 
-bool
-isNaN(double v)
+bool isNaN(double v)
 {
   return fpclassify(v) == FP_NAN;
 }
 
-bool
-isNaN(float v)
+bool isNaN(float v)
 {
   return fpclassify(v) == FP_NAN;
 }
@@ -690,8 +682,7 @@ uint64_t findExceptionHandler(Thread* t, GcMethod* method, unsigned ip)
       uint64_t eh = eht->body()[i];
 
       if (ip - 1 >= exceptionHandlerStart(eh)
-          and ip - 1 < exceptionHandlerEnd(eh))
-      {
+          and ip - 1 < exceptionHandlerEnd(eh)) {
         GcClass* catchType = 0;
         if (exceptionHandlerCatchType(eh)) {
           GcThrowable* e = t->exception;
@@ -699,8 +690,8 @@ uint64_t findExceptionHandler(Thread* t, GcMethod* method, unsigned ip)
           PROTECT(t, e);
 
           PROTECT(t, eht);
-          catchType = resolveClassInPool
-            (t, method, exceptionHandlerCatchType(eh) - 1);
+          catchType = resolveClassInPool(
+              t, method, exceptionHandlerCatchType(eh) - 1);
 
           if (catchType) {
             eh = eht->body()[i];
@@ -721,8 +712,7 @@ uint64_t findExceptionHandler(Thread* t, GcMethod* method, unsigned ip)
   return 0;
 }
 
-uint64_t
-findExceptionHandler(Thread* t, int frame)
+uint64_t findExceptionHandler(Thread* t, int frame)
 {
   return findExceptionHandler(t, frameMethod(t, frame), frameIp(t, frame));
 }
@@ -759,14 +749,14 @@ void pushField(Thread* t, object target, GcField* field)
   }
 }
 
-void safePoint(Thread* t) {
+void safePoint(Thread* t)
+{
   if (UNLIKELY(t->m->exclusive)) {
     ENTER(t, Thread::IdleState);
   }
 }
 
-object
-interpret3(Thread* t, const int base)
+object interpret3(Thread* t, const int base)
 {
   unsigned instruction = nop;
   unsigned& ip = t->ip;
@@ -784,8 +774,8 @@ interpret3(Thread* t, const int base)
     goto throw_;
   }
 
- loop:
-   instruction = code->body()[ip++];
+loop:
+  instruction = code->body()[ip++];
 
   if (DebugRun) {
     fprintf(stderr,
@@ -814,9 +804,9 @@ interpret3(Thread* t, const int base)
     object array = popObject(t);
 
     if (LIKELY(array)) {
-      if (LIKELY(index >= 0 and
-                 static_cast<uintptr_t>(index) < objectArrayLength(t, array)))
-      {
+      if (LIKELY(index >= 0
+                 and static_cast<uintptr_t>(index)
+                     < objectArrayLength(t, array))) {
         pushObject(t, objectArrayBody(t, array, index));
       } else {
         exception = makeThrowable(t,
@@ -830,7 +820,8 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case aastore: {
     object value = popObject(t);
@@ -838,9 +829,9 @@ interpret3(Thread* t, const int base)
     object array = popObject(t);
 
     if (LIKELY(array)) {
-      if (LIKELY(index >= 0 and
-                 static_cast<uintptr_t>(index) < objectArrayLength(t, array)))
-      {
+      if (LIKELY(index >= 0
+                 and static_cast<uintptr_t>(index)
+                     < objectArrayLength(t, array))) {
         setField(t, array, ArrayBody + (index * BytesPerWord), value);
       } else {
         exception = makeThrowable(t,
@@ -854,31 +845,38 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case aconst_null: {
     pushObject(t, 0);
-  } goto loop;
+  }
+    goto loop;
 
   case aload: {
     pushObject(t, localObject(t, code->body()[ip++]));
-  } goto loop;
+  }
+    goto loop;
 
   case aload_0: {
     pushObject(t, localObject(t, 0));
-  } goto loop;
+  }
+    goto loop;
 
   case aload_1: {
     pushObject(t, localObject(t, 1));
-  } goto loop;
+  }
+    goto loop;
 
   case aload_2: {
     pushObject(t, localObject(t, 2));
-  } goto loop;
+  }
+    goto loop;
 
   case aload_3: {
     pushObject(t, localObject(t, 3));
-  } goto loop;
+  }
+    goto loop;
 
   case anewarray: {
     int32_t count = popInt(t);
@@ -894,7 +892,8 @@ interpret3(Thread* t, const int base)
           = makeThrowable(t, GcNegativeArraySizeException::Type, "%d", count);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case areturn: {
     object result = popObject(t);
@@ -905,7 +904,8 @@ interpret3(Thread* t, const int base)
     } else {
       return result;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case arraylength: {
     object array = popObject(t);
@@ -915,34 +915,41 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case astore: {
     store(t, code->body()[ip++]);
-  } goto loop;
+  }
+    goto loop;
 
   case astore_0: {
     store(t, 0);
-  } goto loop;
+  }
+    goto loop;
 
   case astore_1: {
     store(t, 1);
-  } goto loop;
+  }
+    goto loop;
 
   case astore_2: {
     store(t, 2);
-  } goto loop;
+  }
+    goto loop;
 
   case astore_3: {
     store(t, 3);
-  } goto loop;
+  }
+    goto loop;
 
   case athrow: {
     exception = cast<GcThrowable>(t, popObject(t));
     if (UNLIKELY(exception == 0)) {
       exception = makeThrowable(t, GcNullPointerException::Type);
     }
-  } goto throw_;
+  }
+    goto throw_;
 
   case baload: {
     int32_t index = popInt(t);
@@ -980,7 +987,8 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case bastore: {
     int8_t value = popInt(t);
@@ -1019,11 +1027,13 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case bipush: {
     pushInt(t, static_cast<int8_t>(code->body()[ip++]));
-  } goto loop;
+  }
+    goto loop;
 
   case caload: {
     int32_t index = popInt(t);
@@ -1045,7 +1055,8 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case castore: {
     uint16_t value = popInt(t);
@@ -1068,14 +1079,16 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case checkcast: {
     uint16_t index = codeReadInt16(t, code, ip);
 
     if (peekObject(t, sp - 1)) {
       GcClass* class_ = resolveClassInPool(t, frameMethod(t, frame), index - 1);
-      if (UNLIKELY(exception)) goto throw_;
+      if (UNLIKELY(exception))
+        goto throw_;
 
       if (not instanceOf(t, class_, peekObject(t, sp - 1))) {
         exception = makeThrowable(
@@ -1087,42 +1100,59 @@ interpret3(Thread* t, const int base)
         goto throw_;
       }
     }
-  } goto loop;
+  }
+    goto loop;
 
   case d2f: {
     pushFloat(t, static_cast<float>(popDouble(t)));
-  } goto loop;
+  }
+    goto loop;
 
   case d2i: {
     double f = popDouble(t);
     switch (fpclassify(f)) {
-    case FP_NAN: pushInt(t, 0); break;
-    case FP_INFINITE: pushInt(t, signbit(f) ? INT32_MIN : INT32_MAX); break;
-    default: pushInt
-        (t,  f >= INT32_MAX ? INT32_MAX
-         : (f <= INT32_MIN ? INT32_MIN : static_cast<int32_t>(f)));
+    case FP_NAN:
+      pushInt(t, 0);
+      break;
+    case FP_INFINITE:
+      pushInt(t, signbit(f) ? INT32_MIN : INT32_MAX);
+      break;
+    default:
+      pushInt(t,
+              f >= INT32_MAX
+                  ? INT32_MAX
+                  : (f <= INT32_MIN ? INT32_MIN : static_cast<int32_t>(f)));
       break;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case d2l: {
     double f = popDouble(t);
     switch (fpclassify(f)) {
-    case FP_NAN: pushLong(t, 0); break;
-    case FP_INFINITE: pushLong(t, signbit(f) ? INT64_MIN : INT64_MAX); break;
-    default: pushLong
-        (t,  f >= INT64_MAX ? INT64_MAX
-         : (f <= INT64_MIN ? INT64_MIN : static_cast<int64_t>(f)));
+    case FP_NAN:
+      pushLong(t, 0);
+      break;
+    case FP_INFINITE:
+      pushLong(t, signbit(f) ? INT64_MIN : INT64_MAX);
+      break;
+    default:
+      pushLong(t,
+               f >= INT64_MAX
+                   ? INT64_MAX
+                   : (f <= INT64_MIN ? INT64_MIN : static_cast<int64_t>(f)));
       break;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case dadd: {
     double b = popDouble(t);
     double a = popDouble(t);
 
     pushDouble(t, a + b);
-  } goto loop;
+  }
+    goto loop;
 
   case daload: {
     int32_t index = popInt(t);
@@ -1144,7 +1174,8 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case dastore: {
     double value = popDouble(t);
@@ -1167,7 +1198,8 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case dcmpg: {
     double b = popDouble(t);
@@ -1175,7 +1207,8 @@ interpret3(Thread* t, const int base)
 
     if (isNaN(a) or isNaN(b)) {
       pushInt(t, 1);
-    } if (a < b) {
+    }
+    if (a < b) {
       pushInt(t, static_cast<unsigned>(-1));
     } else if (a > b) {
       pushInt(t, 1);
@@ -1184,7 +1217,8 @@ interpret3(Thread* t, const int base)
     } else {
       pushInt(t, 1);
     }
-  } goto loop;
+  }
+    goto loop;
 
   case dcmpl: {
     double b = popDouble(t);
@@ -1192,7 +1226,8 @@ interpret3(Thread* t, const int base)
 
     if (isNaN(a) or isNaN(b)) {
       pushInt(t, static_cast<unsigned>(-1));
-    } if (a < b) {
+    }
+    if (a < b) {
       pushInt(t, static_cast<unsigned>(-1));
     } else if (a > b) {
       pushInt(t, 1);
@@ -1201,90 +1236,102 @@ interpret3(Thread* t, const int base)
     } else {
       pushInt(t, static_cast<unsigned>(-1));
     }
-  } goto loop;
+  }
+    goto loop;
 
   case dconst_0: {
     pushDouble(t, 0);
-  } goto loop;
+  }
+    goto loop;
 
   case dconst_1: {
     pushDouble(t, 1);
-  } goto loop;
+  }
+    goto loop;
 
   case ddiv: {
     double b = popDouble(t);
     double a = popDouble(t);
 
     pushDouble(t, a / b);
-  } goto loop;
+  }
+    goto loop;
 
   case dmul: {
     double b = popDouble(t);
     double a = popDouble(t);
 
     pushDouble(t, a * b);
-  } goto loop;
+  }
+    goto loop;
 
   case dneg: {
     double a = popDouble(t);
 
-    pushDouble(t, - a);
-  } goto loop;
+    pushDouble(t, -a);
+  }
+    goto loop;
 
   case vm::drem: {
     double b = popDouble(t);
     double a = popDouble(t);
 
     pushDouble(t, fmod(a, b));
-  } goto loop;
+  }
+    goto loop;
 
   case dsub: {
     double b = popDouble(t);
     double a = popDouble(t);
 
     pushDouble(t, a - b);
-  } goto loop;
+  }
+    goto loop;
 
   case dup: {
     if (DebugStack) {
       fprintf(stderr, "dup\n");
     }
 
-    memcpy(stack + ((sp    ) * 2), stack + ((sp - 1) * 2), BytesPerWord * 2);
-    ++ sp;
-  } goto loop;
+    memcpy(stack + ((sp)*2), stack + ((sp - 1) * 2), BytesPerWord * 2);
+    ++sp;
+  }
+    goto loop;
 
   case dup_x1: {
     if (DebugStack) {
       fprintf(stderr, "dup_x1\n");
     }
 
-    memcpy(stack + ((sp    ) * 2), stack + ((sp - 1) * 2), BytesPerWord * 2);
+    memcpy(stack + ((sp)*2), stack + ((sp - 1) * 2), BytesPerWord * 2);
     memcpy(stack + ((sp - 1) * 2), stack + ((sp - 2) * 2), BytesPerWord * 2);
-    memcpy(stack + ((sp - 2) * 2), stack + ((sp    ) * 2), BytesPerWord * 2);
-    ++ sp;
-  } goto loop;
+    memcpy(stack + ((sp - 2) * 2), stack + ((sp)*2), BytesPerWord * 2);
+    ++sp;
+  }
+    goto loop;
 
   case dup_x2: {
     if (DebugStack) {
       fprintf(stderr, "dup_x2\n");
     }
 
-    memcpy(stack + ((sp    ) * 2), stack + ((sp - 1) * 2), BytesPerWord * 2);
+    memcpy(stack + ((sp)*2), stack + ((sp - 1) * 2), BytesPerWord * 2);
     memcpy(stack + ((sp - 1) * 2), stack + ((sp - 2) * 2), BytesPerWord * 2);
     memcpy(stack + ((sp - 2) * 2), stack + ((sp - 3) * 2), BytesPerWord * 2);
-    memcpy(stack + ((sp - 3) * 2), stack + ((sp    ) * 2), BytesPerWord * 2);
-    ++ sp;
-  } goto loop;
+    memcpy(stack + ((sp - 3) * 2), stack + ((sp)*2), BytesPerWord * 2);
+    ++sp;
+  }
+    goto loop;
 
   case dup2: {
     if (DebugStack) {
       fprintf(stderr, "dup2\n");
     }
 
-    memcpy(stack + ((sp    ) * 2), stack + ((sp - 2) * 2), BytesPerWord * 4);
+    memcpy(stack + ((sp)*2), stack + ((sp - 2) * 2), BytesPerWord * 4);
     sp += 2;
-  } goto loop;
+  }
+    goto loop;
 
   case dup2_x1: {
     if (DebugStack) {
@@ -1292,11 +1339,12 @@ interpret3(Thread* t, const int base)
     }
 
     memcpy(stack + ((sp + 1) * 2), stack + ((sp - 1) * 2), BytesPerWord * 2);
-    memcpy(stack + ((sp    ) * 2), stack + ((sp - 2) * 2), BytesPerWord * 2);
+    memcpy(stack + ((sp)*2), stack + ((sp - 2) * 2), BytesPerWord * 2);
     memcpy(stack + ((sp - 1) * 2), stack + ((sp - 3) * 2), BytesPerWord * 2);
-    memcpy(stack + ((sp - 3) * 2), stack + ((sp    ) * 2), BytesPerWord * 4);
+    memcpy(stack + ((sp - 3) * 2), stack + ((sp)*2), BytesPerWord * 4);
     sp += 2;
-  } goto loop;
+  }
+    goto loop;
 
   case dup2_x2: {
     if (DebugStack) {
@@ -1304,44 +1352,61 @@ interpret3(Thread* t, const int base)
     }
 
     memcpy(stack + ((sp + 1) * 2), stack + ((sp - 1) * 2), BytesPerWord * 2);
-    memcpy(stack + ((sp    ) * 2), stack + ((sp - 2) * 2), BytesPerWord * 2);
+    memcpy(stack + ((sp)*2), stack + ((sp - 2) * 2), BytesPerWord * 2);
     memcpy(stack + ((sp - 1) * 2), stack + ((sp - 3) * 2), BytesPerWord * 2);
     memcpy(stack + ((sp - 2) * 2), stack + ((sp - 4) * 2), BytesPerWord * 2);
-    memcpy(stack + ((sp - 4) * 2), stack + ((sp    ) * 2), BytesPerWord * 4);
+    memcpy(stack + ((sp - 4) * 2), stack + ((sp)*2), BytesPerWord * 4);
     sp += 2;
-  } goto loop;
+  }
+    goto loop;
 
   case f2d: {
     pushDouble(t, popFloat(t));
-  } goto loop;
+  }
+    goto loop;
 
   case f2i: {
     float f = popFloat(t);
     switch (fpclassify(f)) {
-    case FP_NAN: pushInt(t, 0); break;
-    case FP_INFINITE: pushInt(t, signbit(f) ? INT32_MIN : INT32_MAX); break;
-    default: pushInt(t, f >= INT32_MAX ? INT32_MAX
-                     : (f <= INT32_MIN ? INT32_MIN : static_cast<int32_t>(f)));
+    case FP_NAN:
+      pushInt(t, 0);
+      break;
+    case FP_INFINITE:
+      pushInt(t, signbit(f) ? INT32_MIN : INT32_MAX);
+      break;
+    default:
+      pushInt(t,
+              f >= INT32_MAX
+                  ? INT32_MAX
+                  : (f <= INT32_MIN ? INT32_MIN : static_cast<int32_t>(f)));
       break;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case f2l: {
     float f = popFloat(t);
     switch (fpclassify(f)) {
-    case FP_NAN: pushLong(t, 0); break;
-    case FP_INFINITE: pushLong(t, signbit(f) ? INT64_MIN : INT64_MAX);
+    case FP_NAN:
+      pushLong(t, 0);
+      break;
+    case FP_INFINITE:
+      pushLong(t, signbit(f) ? INT64_MIN : INT64_MAX);
+      break;
+    default:
+      pushLong(t, static_cast<int64_t>(f));
       break;
-    default: pushLong(t, static_cast<int64_t>(f)); break;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case fadd: {
     float b = popFloat(t);
     float a = popFloat(t);
 
     pushFloat(t, a + b);
-  } goto loop;
+  }
+    goto loop;
 
   case faload: {
     int32_t index = popInt(t);
@@ -1363,7 +1428,8 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case fastore: {
     float value = popFloat(t);
@@ -1386,7 +1452,8 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case fcmpg: {
     float b = popFloat(t);
@@ -1394,7 +1461,8 @@ interpret3(Thread* t, const int base)
 
     if (isNaN(a) or isNaN(b)) {
       pushInt(t, 1);
-    } if (a < b) {
+    }
+    if (a < b) {
       pushInt(t, static_cast<unsigned>(-1));
     } else if (a > b) {
       pushInt(t, 1);
@@ -1403,7 +1471,8 @@ interpret3(Thread* t, const int base)
     } else {
       pushInt(t, 1);
     }
-  } goto loop;
+  }
+    goto loop;
 
   case fcmpl: {
     float b = popFloat(t);
@@ -1411,7 +1480,8 @@ interpret3(Thread* t, const int base)
 
     if (isNaN(a) or isNaN(b)) {
       pushInt(t, static_cast<unsigned>(-1));
-    } if (a < b) {
+    }
+    if (a < b) {
       pushInt(t, static_cast<unsigned>(-1));
     } else if (a > b) {
       pushInt(t, 1);
@@ -1420,53 +1490,62 @@ interpret3(Thread* t, const int base)
     } else {
       pushInt(t, static_cast<unsigned>(-1));
     }
-  } goto loop;
+  }
+    goto loop;
 
   case fconst_0: {
     pushFloat(t, 0);
-  } goto loop;
+  }
+    goto loop;
 
   case fconst_1: {
     pushFloat(t, 1);
-  } goto loop;
+  }
+    goto loop;
 
   case fconst_2: {
     pushFloat(t, 2);
-  } goto loop;
+  }
+    goto loop;
 
   case fdiv: {
     float b = popFloat(t);
     float a = popFloat(t);
 
     pushFloat(t, a / b);
-  } goto loop;
+  }
+    goto loop;
 
   case fmul: {
     float b = popFloat(t);
     float a = popFloat(t);
 
     pushFloat(t, a * b);
-  } goto loop;
+  }
+    goto loop;
 
   case fneg: {
     float a = popFloat(t);
 
-    pushFloat(t, - a);
-  } goto loop;
+    pushFloat(t, -a);
+  }
+    goto loop;
 
   case frem: {
     float b = popFloat(t);
     float a = popFloat(t);
 
     pushFloat(t, fmodf(a, b));
-  } goto loop;
+  }
+    goto loop;
 
   case fsub: {
     float b = popFloat(t);
     float a = popFloat(t);
 
     pushFloat(t, a - b);
-  } goto loop;
+  }
+    goto loop;
 
   case getfield: {
     if (LIKELY(peekObject(t, sp - 1))) {
@@ -1485,7 +1564,8 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case getstatic: {
     uint16_t index = codeReadInt16(t, code, ip);
@@ -1501,48 +1581,58 @@ interpret3(Thread* t, const int base)
     ACQUIRE_FIELD_FOR_READ(t, field);
 
     pushField(t, field->class_()->staticTable(), field);
-  } goto loop;
+  }
+    goto loop;
 
   case goto_: {
     int16_t offset = codeReadInt16(t, code, ip);
     ip = (ip - 3) + offset;
-  } goto back_branch;
+  }
+    goto back_branch;
 
   case goto_w: {
     int32_t offset = codeReadInt32(t, code, ip);
     ip = (ip - 5) + offset;
-  } goto back_branch;
+  }
+    goto back_branch;
 
   case i2b: {
     pushInt(t, static_cast<int8_t>(popInt(t)));
-  } goto loop;
+  }
+    goto loop;
 
   case i2c: {
     pushInt(t, static_cast<uint16_t>(popInt(t)));
-  } goto loop;
+  }
+    goto loop;
 
   case i2d: {
     pushDouble(t, static_cast<double>(static_cast<int32_t>(popInt(t))));
-  } goto loop;
+  }
+    goto loop;
 
   case i2f: {
     pushFloat(t, static_cast<float>(static_cast<int32_t>(popInt(t))));
-  } goto loop;
+  }
+    goto loop;
 
   case i2l: {
     pushLong(t, static_cast<int32_t>(popInt(t)));
-  } goto loop;
+  }
+    goto loop;
 
   case i2s: {
     pushInt(t, static_cast<int16_t>(popInt(t)));
-  } goto loop;
+  }
+    goto loop;
 
   case iadd: {
     int32_t b = popInt(t);
     int32_t a = popInt(t);
 
     pushInt(t, a + b);
-  } goto loop;
+  }
+    goto loop;
 
   case iaload: {
     int32_t index = popInt(t);
@@ -1564,14 +1654,16 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case iand: {
     int32_t b = popInt(t);
     int32_t a = popInt(t);
 
     pushInt(t, a & b);
-  } goto loop;
+  }
+    goto loop;
 
   case iastore: {
     int32_t value = popInt(t);
@@ -1594,35 +1686,43 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case iconst_m1: {
     pushInt(t, static_cast<unsigned>(-1));
-  } goto loop;
+  }
+    goto loop;
 
   case iconst_0: {
     pushInt(t, 0);
-  } goto loop;
+  }
+    goto loop;
 
   case iconst_1: {
     pushInt(t, 1);
-  } goto loop;
+  }
+    goto loop;
 
   case iconst_2: {
     pushInt(t, 2);
-  } goto loop;
+  }
+    goto loop;
 
   case iconst_3: {
     pushInt(t, 3);
-  } goto loop;
+  }
+    goto loop;
 
   case iconst_4: {
     pushInt(t, 4);
-  } goto loop;
+  }
+    goto loop;
 
   case iconst_5: {
     pushInt(t, 5);
-  } goto loop;
+  }
+    goto loop;
 
   case idiv: {
     int32_t b = popInt(t);
@@ -1634,7 +1734,8 @@ interpret3(Thread* t, const int base)
     }
 
     pushInt(t, a / b);
-  } goto loop;
+  }
+    goto loop;
 
   case if_acmpeq: {
     int16_t offset = codeReadInt16(t, code, ip);
@@ -1645,7 +1746,8 @@ interpret3(Thread* t, const int base)
     if (a == b) {
       ip = (ip - 3) + offset;
     }
-  } goto back_branch;
+  }
+    goto back_branch;
 
   case if_acmpne: {
     int16_t offset = codeReadInt16(t, code, ip);
@@ -1656,7 +1758,8 @@ interpret3(Thread* t, const int base)
     if (a != b) {
       ip = (ip - 3) + offset;
     }
-  } goto back_branch;
+  }
+    goto back_branch;
 
   case if_icmpeq: {
     int16_t offset = codeReadInt16(t, code, ip);
@@ -1667,7 +1770,8 @@ interpret3(Thread* t, const int base)
     if (a == b) {
       ip = (ip - 3) + offset;
     }
-  } goto back_branch;
+  }
+    goto back_branch;
 
   case if_icmpne: {
     int16_t offset = codeReadInt16(t, code, ip);
@@ -1678,7 +1782,8 @@ interpret3(Thread* t, const int base)
     if (a != b) {
       ip = (ip - 3) + offset;
     }
-  } goto back_branch;
+  }
+    goto back_branch;
 
   case if_icmpgt: {
     int16_t offset = codeReadInt16(t, code, ip);
@@ -1689,7 +1794,8 @@ interpret3(Thread* t, const int base)
     if (a > b) {
       ip = (ip - 3) + offset;
     }
-  } goto back_branch;
+  }
+    goto back_branch;
 
   case if_icmpge: {
     int16_t offset = codeReadInt16(t, code, ip);
@@ -1700,7 +1806,8 @@ interpret3(Thread* t, const int base)
     if (a >= b) {
       ip = (ip - 3) + offset;
     }
-  } goto back_branch;
+  }
+    goto back_branch;
 
   case if_icmplt: {
     int16_t offset = codeReadInt16(t, code, ip);
@@ -1711,7 +1818,8 @@ interpret3(Thread* t, const int base)
     if (a < b) {
       ip = (ip - 3) + offset;
     }
-  } goto back_branch;
+  }
+    goto back_branch;
 
   case if_icmple: {
     int16_t offset = codeReadInt16(t, code, ip);
@@ -1722,7 +1830,8 @@ interpret3(Thread* t, const int base)
     if (a <= b) {
       ip = (ip - 3) + offset;
     }
-  } goto back_branch;
+  }
+    goto back_branch;
 
   case ifeq: {
     int16_t offset = codeReadInt16(t, code, ip);
@@ -1730,7 +1839,8 @@ interpret3(Thread* t, const int base)
     if (popInt(t) == 0) {
       ip = (ip - 3) + offset;
     }
-  } goto back_branch;
+  }
+    goto back_branch;
 
   case ifne: {
     int16_t offset = codeReadInt16(t, code, ip);
@@ -1738,7 +1848,8 @@ interpret3(Thread* t, const int base)
     if (popInt(t)) {
       ip = (ip - 3) + offset;
     }
-  } goto back_branch;
+  }
+    goto back_branch;
 
   case ifgt: {
     int16_t offset = codeReadInt16(t, code, ip);
@@ -1746,7 +1857,8 @@ interpret3(Thread* t, const int base)
     if (static_cast<int32_t>(popInt(t)) > 0) {
       ip = (ip - 3) + offset;
     }
-  } goto back_branch;
+  }
+    goto back_branch;
 
   case ifge: {
     int16_t offset = codeReadInt16(t, code, ip);
@@ -1754,7 +1866,8 @@ interpret3(Thread* t, const int base)
     if (static_cast<int32_t>(popInt(t)) >= 0) {
       ip = (ip - 3) + offset;
     }
-  } goto back_branch;
+  }
+    goto back_branch;
 
   case iflt: {
     int16_t offset = codeReadInt16(t, code, ip);
@@ -1762,7 +1875,8 @@ interpret3(Thread* t, const int base)
     if (static_cast<int32_t>(popInt(t)) < 0) {
       ip = (ip - 3) + offset;
     }
-  } goto back_branch;
+  }
+    goto back_branch;
 
   case ifle: {
     int16_t offset = codeReadInt16(t, code, ip);
@@ -1770,7 +1884,8 @@ interpret3(Thread* t, const int base)
     if (static_cast<int32_t>(popInt(t)) <= 0) {
       ip = (ip - 3) + offset;
     }
-  } goto back_branch;
+  }
+    goto back_branch;
 
   case ifnonnull: {
     int16_t offset = codeReadInt16(t, code, ip);
@@ -1778,7 +1893,8 @@ interpret3(Thread* t, const int base)
     if (popObject(t)) {
       ip = (ip - 3) + offset;
     }
-  } goto back_branch;
+  }
+    goto back_branch;
 
   case ifnull: {
     int16_t offset = codeReadInt16(t, code, ip);
@@ -1786,50 +1902,59 @@ interpret3(Thread* t, const int base)
     if (popObject(t) == 0) {
       ip = (ip - 3) + offset;
     }
-  } goto back_branch;
+  }
+    goto back_branch;
 
   case iinc: {
     uint8_t index = code->body()[ip++];
     int8_t c = code->body()[ip++];
 
     setLocalInt(t, index, localInt(t, index) + c);
-  } goto loop;
+  }
+    goto loop;
 
   case iload:
   case fload: {
     pushInt(t, localInt(t, code->body()[ip++]));
-  } goto loop;
+  }
+    goto loop;
 
   case iload_0:
   case fload_0: {
     pushInt(t, localInt(t, 0));
-  } goto loop;
+  }
+    goto loop;
 
   case iload_1:
   case fload_1: {
     pushInt(t, localInt(t, 1));
-  } goto loop;
+  }
+    goto loop;
 
   case iload_2:
   case fload_2: {
     pushInt(t, localInt(t, 2));
-  } goto loop;
+  }
+    goto loop;
 
   case iload_3:
   case fload_3: {
     pushInt(t, localInt(t, 3));
-  } goto loop;
+  }
+    goto loop;
 
   case imul: {
     int32_t b = popInt(t);
     int32_t a = popInt(t);
 
     pushInt(t, a * b);
-  } goto loop;
+  }
+    goto loop;
 
   case ineg: {
-    pushInt(t, - popInt(t));
-  } goto loop;
+    pushInt(t, -popInt(t));
+  }
+    goto loop;
 
   case instanceof: {
     uint16_t index = codeReadInt16(t, code, ip);
@@ -1846,7 +1971,8 @@ interpret3(Thread* t, const int base)
       popObject(t);
       pushInt(t, 0);
     }
-  } goto loop;
+  }
+    goto loop;
 
   case invokeinterface: {
     uint16_t index = codeReadInt16(t, code, ip);
@@ -1864,7 +1990,8 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case invokespecial: {
     uint16_t index = codeReadInt16(t, code, ip);
@@ -1891,7 +2018,8 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case invokestatic: {
     uint16_t index = codeReadInt16(t, code, ip);
@@ -1902,7 +2030,8 @@ interpret3(Thread* t, const int base)
     initClass(t, m->class_());
 
     method = m;
-  } goto invoke;
+  }
+    goto invoke;
 
   case invokevirtual: {
     uint16_t index = codeReadInt16(t, code, ip);
@@ -1921,14 +2050,16 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case ior: {
     int32_t b = popInt(t);
     int32_t a = popInt(t);
 
     pushInt(t, a | b);
-  } goto loop;
+  }
+    goto loop;
 
   case irem: {
     int32_t b = popInt(t);
@@ -1940,7 +2071,8 @@ interpret3(Thread* t, const int base)
     }
 
     pushInt(t, a % b);
-  } goto loop;
+  }
+    goto loop;
 
   case ireturn:
   case freturn: {
@@ -1952,100 +2084,117 @@ interpret3(Thread* t, const int base)
     } else {
       return makeInt(t, result);
     }
-  } goto loop;
+  }
+    goto loop;
 
   case ishl: {
     int32_t b = popInt(t);
     int32_t a = popInt(t);
 
     pushInt(t, a << (b & 0x1F));
-  } goto loop;
+  }
+    goto loop;
 
   case ishr: {
     int32_t b = popInt(t);
     int32_t a = popInt(t);
 
     pushInt(t, a >> (b & 0x1F));
-  } goto loop;
+  }
+    goto loop;
 
   case istore:
   case fstore: {
     setLocalInt(t, code->body()[ip++], popInt(t));
-  } goto loop;
+  }
+    goto loop;
 
   case istore_0:
   case fstore_0: {
     setLocalInt(t, 0, popInt(t));
-  } goto loop;
+  }
+    goto loop;
 
   case istore_1:
   case fstore_1: {
     setLocalInt(t, 1, popInt(t));
-  } goto loop;
+  }
+    goto loop;
 
   case istore_2:
   case fstore_2: {
     setLocalInt(t, 2, popInt(t));
-  } goto loop;
+  }
+    goto loop;
 
   case istore_3:
   case fstore_3: {
     setLocalInt(t, 3, popInt(t));
-  } goto loop;
+  }
+    goto loop;
 
   case isub: {
     int32_t b = popInt(t);
     int32_t a = popInt(t);
 
     pushInt(t, a - b);
-  } goto loop;
+  }
+    goto loop;
 
   case iushr: {
     int32_t b = popInt(t);
     uint32_t a = popInt(t);
 
     pushInt(t, a >> (b & 0x1F));
-  } goto loop;
+  }
+    goto loop;
 
   case ixor: {
     int32_t b = popInt(t);
     int32_t a = popInt(t);
 
     pushInt(t, a ^ b);
-  } goto loop;
+  }
+    goto loop;
 
   case jsr: {
     uint16_t offset = codeReadInt16(t, code, ip);
 
     pushInt(t, ip);
     ip = (ip - 3) + static_cast<int16_t>(offset);
-  } goto loop;
+  }
+    goto loop;
 
   case jsr_w: {
     uint32_t offset = codeReadInt32(t, code, ip);
 
     pushInt(t, ip);
     ip = (ip - 5) + static_cast<int32_t>(offset);
-  } goto loop;
+  }
+    goto loop;
 
   case l2d: {
     pushDouble(t, static_cast<double>(static_cast<int64_t>(popLong(t))));
-  } goto loop;
+  }
+    goto loop;
 
   case l2f: {
     pushFloat(t, static_cast<float>(static_cast<int64_t>(popLong(t))));
-  } goto loop;
+  }
+    goto loop;
 
   case l2i: {
     pushInt(t, static_cast<int32_t>(popLong(t)));
-  } goto loop;
+  }
+    goto loop;
 
   case ladd: {
     int64_t b = popLong(t);
     int64_t a = popLong(t);
 
     pushLong(t, a + b);
-  } goto loop;
+  }
+    goto loop;
 
   case laload: {
     int32_t index = popInt(t);
@@ -2067,14 +2216,16 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case land: {
     int64_t b = popLong(t);
     int64_t a = popLong(t);
 
     pushLong(t, a & b);
-  } goto loop;
+  }
+    goto loop;
 
   case lastore: {
     int64_t value = popLong(t);
@@ -2097,22 +2248,26 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case lcmp: {
     int64_t b = popLong(t);
     int64_t a = popLong(t);
 
     pushInt(t, a > b ? 1 : a == b ? 0 : -1);
-  } goto loop;
+  }
+    goto loop;
 
   case lconst_0: {
     pushLong(t, 0);
-  } goto loop;
+  }
+    goto loop;
 
   case lconst_1: {
     pushLong(t, 1);
-  } goto loop;
+  }
+    goto loop;
 
   case ldc:
   case ldc_w: {
@@ -2142,7 +2297,8 @@ interpret3(Thread* t, const int base)
     } else {
       pushInt(t, singletonValue(t, pool, index - 1));
     }
-  } goto loop;
+  }
+    goto loop;
 
   case ldc2_w: {
     uint16_t index = codeReadInt16(t, code, ip);
@@ -2152,7 +2308,8 @@ interpret3(Thread* t, const int base)
     uint64_t v;
     memcpy(&v, &singletonValue(t, pool, index - 1), 8);
     pushLong(t, v);
-  } goto loop;
+  }
+    goto loop;
 
   case ldiv_: {
     int64_t b = popLong(t);
@@ -2164,43 +2321,51 @@ interpret3(Thread* t, const int base)
     }
 
     pushLong(t, a / b);
-  } goto loop;
+  }
+    goto loop;
 
   case lload:
   case dload: {
     pushLong(t, localLong(t, code->body()[ip++]));
-  } goto loop;
+  }
+    goto loop;
 
   case lload_0:
   case dload_0: {
     pushLong(t, localLong(t, 0));
-  } goto loop;
+  }
+    goto loop;
 
   case lload_1:
   case dload_1: {
     pushLong(t, localLong(t, 1));
-  } goto loop;
+  }
+    goto loop;
 
   case lload_2:
   case dload_2: {
     pushLong(t, localLong(t, 2));
-  } goto loop;
+  }
+    goto loop;
 
   case lload_3:
   case dload_3: {
     pushLong(t, localLong(t, 3));
-  } goto loop;
+  }
+    goto loop;
 
   case lmul: {
     int64_t b = popLong(t);
     int64_t a = popLong(t);
 
     pushLong(t, a * b);
-  } goto loop;
+  }
+    goto loop;
 
   case lneg: {
-    pushLong(t, - popLong(t));
-  } goto loop;
+    pushLong(t, -popLong(t));
+  }
+    goto loop;
 
   case lookupswitch: {
     int32_t base = ip - 1;
@@ -2232,14 +2397,16 @@ interpret3(Thread* t, const int base)
     }
 
     ip = base + default_;
-  } goto loop;
+  }
+    goto loop;
 
   case lor: {
     int64_t b = popLong(t);
     int64_t a = popLong(t);
 
     pushLong(t, a | b);
-  } goto loop;
+  }
+    goto loop;
 
   case lrem: {
     int64_t b = popLong(t);
@@ -2251,7 +2418,8 @@ interpret3(Thread* t, const int base)
     }
 
     pushLong(t, a % b);
-  } goto loop;
+  }
+    goto loop;
 
   case lreturn:
   case dreturn: {
@@ -2263,67 +2431,78 @@ interpret3(Thread* t, const int base)
     } else {
       return makeLong(t, result);
     }
-  } goto loop;
+  }
+    goto loop;
 
   case lshl: {
     int32_t b = popInt(t);
     int64_t a = popLong(t);
 
     pushLong(t, a << (b & 0x3F));
-  } goto loop;
+  }
+    goto loop;
 
   case lshr: {
     int32_t b = popInt(t);
     int64_t a = popLong(t);
 
     pushLong(t, a >> (b & 0x3F));
-  } goto loop;
+  }
+    goto loop;
 
   case lstore:
   case dstore: {
     setLocalLong(t, code->body()[ip++], popLong(t));
-  } goto loop;
+  }
+    goto loop;
 
   case lstore_0:
-  case dstore_0:{
+  case dstore_0: {
     setLocalLong(t, 0, popLong(t));
-  } goto loop;
+  }
+    goto loop;
 
   case lstore_1:
   case dstore_1: {
     setLocalLong(t, 1, popLong(t));
-  } goto loop;
+  }
+    goto loop;
 
   case lstore_2:
   case dstore_2: {
     setLocalLong(t, 2, popLong(t));
-  } goto loop;
+  }
+    goto loop;
 
   case lstore_3:
   case dstore_3: {
     setLocalLong(t, 3, popLong(t));
-  } goto loop;
+  }
+    goto loop;
 
   case lsub: {
     int64_t b = popLong(t);
     int64_t a = popLong(t);
 
     pushLong(t, a - b);
-  } goto loop;
+  }
+    goto loop;
 
   case lushr: {
     int64_t b = popInt(t);
     uint64_t a = popLong(t);
 
     pushLong(t, a >> (b & 0x3F));
-  } goto loop;
+  }
+    goto loop;
 
   case lxor: {
     int64_t b = popLong(t);
     int64_t a = popLong(t);
 
     pushLong(t, a ^ b);
-  } goto loop;
+  }
+    goto loop;
 
   case monitorenter: {
     object o = popObject(t);
@@ -2333,7 +2512,8 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case monitorexit: {
     object o = popObject(t);
@@ -2343,7 +2523,8 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case multianewarray: {
     uint16_t index = codeReadInt16(t, code, ip);
@@ -2371,7 +2552,8 @@ interpret3(Thread* t, const int base)
     populateMultiArray(t, array, RUNTIME_ARRAY_BODY(counts), 0, dimensions);
 
     pushObject(t, array);
-  } goto loop;
+  }
+    goto loop;
 
   case new_: {
     uint16_t index = codeReadInt16(t, code, ip);
@@ -2382,7 +2564,8 @@ interpret3(Thread* t, const int base)
     initClass(t, class_);
 
     pushObject(t, make(t, class_));
-  } goto loop;
+  }
+    goto loop;
 
   case newarray: {
     int32_t count = popInt(t);
@@ -2425,7 +2608,8 @@ interpret3(Thread* t, const int base)
         array = makeLongArray(t, count);
         break;
 
-      default: abort(t);
+      default:
+        abort(t);
       }
 
       pushObject(t, array);
@@ -2434,17 +2618,21 @@ interpret3(Thread* t, const int base)
           = makeThrowable(t, GcNegativeArraySizeException::Type, "%d", count);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
-  case nop: goto loop;
+  case nop:
+    goto loop;
 
   case pop_: {
-    -- sp;
-  } goto loop;
+    --sp;
+  }
+    goto loop;
 
   case pop2: {
     sp -= 2;
-  } goto loop;
+  }
+    goto loop;
 
   case putfield: {
     uint16_t index = codeReadInt16(t, code, ip);
@@ -2454,7 +2642,8 @@ interpret3(Thread* t, const int base)
     assertT(t, (field->flags() & ACC_STATIC) == 0);
     PROTECT(t, field);
 
-    { ACQUIRE_FIELD_FOR_WRITE(t, field);
+    {
+      ACQUIRE_FIELD_FOR_WRITE(t, field);
 
       switch (field->code()) {
       case ByteField:
@@ -2508,14 +2697,16 @@ interpret3(Thread* t, const int base)
         }
       } break;
 
-      default: abort(t);
+      default:
+        abort(t);
       }
     }
 
     if (UNLIKELY(exception)) {
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case putstatic: {
     uint16_t index = codeReadInt16(t, code, ip);
@@ -2567,13 +2758,16 @@ interpret3(Thread* t, const int base)
       setField(t, table, field->offset(), popObject(t));
     } break;
 
-    default: abort(t);
+    default:
+      abort(t);
     }
-  } goto loop;
+  }
+    goto loop;
 
   case ret: {
     ip = localInt(t, code->body()[ip]);
-  } goto loop;
+  }
+    goto loop;
 
   case return_: {
     GcMethod* method = frameMethod(t, frame);
@@ -2588,7 +2782,8 @@ interpret3(Thread* t, const int base)
     } else {
       return 0;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case saload: {
     int32_t index = popInt(t);
@@ -2610,7 +2805,8 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case sastore: {
     int16_t value = popInt(t);
@@ -2633,18 +2829,21 @@ interpret3(Thread* t, const int base)
       exception = makeThrowable(t, GcNullPointerException::Type);
       goto throw_;
     }
-  } goto loop;
+  }
+    goto loop;
 
   case sipush: {
     pushInt(t, static_cast<int16_t>(codeReadInt16(t, code, ip)));
-  } goto loop;
+  }
+    goto loop;
 
   case swap: {
     uintptr_t tmp[2];
-    memcpy(tmp                   , stack + ((sp - 1) * 2), BytesPerWord * 2);
+    memcpy(tmp, stack + ((sp - 1) * 2), BytesPerWord * 2);
     memcpy(stack + ((sp - 1) * 2), stack + ((sp - 2) * 2), BytesPerWord * 2);
-    memcpy(stack + ((sp - 2) * 2), tmp                   , BytesPerWord * 2);
-  } goto loop;
+    memcpy(stack + ((sp - 2) * 2), tmp, BytesPerWord * 2);
+  }
+    goto loop;
 
   case tableswitch: {
     int32_t base = ip - 1;
@@ -2664,9 +2863,11 @@ interpret3(Thread* t, const int base)
     } else {
       ip = base + default_;
     }
-  } goto loop;
+  }
+    goto loop;
 
-  case wide: goto wide;
+  case wide:
+    goto wide;
 
   case impdep1: {
     // this means we're invoking a virtual method on an instance of a
@@ -2689,65 +2890,77 @@ interpret3(Thread* t, const int base)
     resolveClass(t, frameMethod(t, frame)->class_()->loader(), class_->name());
 
     ip -= 3;
-  } goto loop;
+  }
+    goto loop;
 
-  default: abort(t);
+  default:
+    abort(t);
   }
 
- wide:
-   switch (code->body()[ip++]) {
+wide:
+  switch (code->body()[ip++]) {
   case aload: {
     pushObject(t, localObject(t, codeReadInt16(t, code, ip)));
-  } goto loop;
+  }
+    goto loop;
 
   case astore: {
     setLocalObject(t, codeReadInt16(t, code, ip), popObject(t));
-  } goto loop;
+  }
+    goto loop;
 
   case iinc: {
     uint16_t index = codeReadInt16(t, code, ip);
     int16_t count = codeReadInt16(t, code, ip);
 
     setLocalInt(t, index, localInt(t, index) + count);
-  } goto loop;
+  }
+    goto loop;
 
   case iload: {
     pushInt(t, localInt(t, codeReadInt16(t, code, ip)));
-  } goto loop;
+  }
+    goto loop;
 
   case istore: {
     setLocalInt(t, codeReadInt16(t, code, ip), popInt(t));
-  } goto loop;
+  }
+    goto loop;
 
   case lload: {
     pushLong(t, localLong(t, codeReadInt16(t, code, ip)));
-  } goto loop;
+  }
+    goto loop;
 
   case lstore: {
-    setLocalLong(t, codeReadInt16(t, code, ip),  popLong(t));
-  } goto loop;
+    setLocalLong(t, codeReadInt16(t, code, ip), popLong(t));
+  }
+    goto loop;
 
   case ret: {
     ip = localInt(t, codeReadInt16(t, code, ip));
-  } goto loop;
+  }
+    goto loop;
 
-  default: abort(t);
+  default:
+    abort(t);
   }
 
- back_branch:
+back_branch:
   safePoint(t);
   goto loop;
 
- invoke: {
-   if (method->flags() & ACC_NATIVE) {
-     invokeNative(t, method);
-    } else {
-      checkStack(t, method);
-      pushFrame(t, method);
-    }
-  } goto loop;
+invoke : {
+  if (method->flags() & ACC_NATIVE) {
+    invokeNative(t, method);
+  } else {
+    checkStack(t, method);
+    pushFrame(t, method);
+  }
+}
+  goto loop;
 
- throw_:
+throw_:
   if (DebugRun) {
     fprintf(stderr, "throw\n");
   }
@@ -2767,8 +2980,7 @@ interpret3(Thread* t, const int base)
   return 0;
 }
 
-uint64_t
-interpret2(vm::Thread* t, uintptr_t* arguments)
+uint64_t interpret2(vm::Thread* t, uintptr_t* arguments)
 {
   int base = arguments[0];
   bool* success = reinterpret_cast<bool*>(arguments[1]);
@@ -2778,15 +2990,14 @@ interpret2(vm::Thread* t, uintptr_t* arguments)
   return reinterpret_cast<uint64_t>(r);
 }
 
-object
-interpret(Thread* t)
+object interpret(Thread* t)
 {
   const int base = t->frame;
 
   while (true) {
     bool success = false;
-    uintptr_t arguments[] = { static_cast<uintptr_t>(base),
-                              reinterpret_cast<uintptr_t>(&success) };
+    uintptr_t arguments[]
+        = {static_cast<uintptr_t>(base), reinterpret_cast<uintptr_t>(&success)};
 
     uint64_t r = run(t, interpret2, arguments);
     if (success) {
@@ -2801,9 +3012,11 @@ interpret(Thread* t)
   }
 }
 
-void
-pushArguments(Thread* t, object this_, const char* spec, bool indirectObjects,
-              va_list a)
+void pushArguments(Thread* t,
+                   object this_,
+                   const char* spec,
+                   bool indirectObjects,
+                   va_list a)
 {
   if (this_) {
     pushObject(t, this_);
@@ -2837,9 +3050,10 @@ pushArguments(Thread* t, object this_, const char* spec, bool indirectObjects,
   }
 }
 
-void
-pushArguments(Thread* t, object this_, const char* spec,
-              const jvalue* arguments)
+void pushArguments(Thread* t,
+                   object this_,
+                   const char* spec,
+                   const jvalue* arguments)
 {
   if (this_) {
     pushObject(t, this_);
@@ -2870,8 +3084,7 @@ pushArguments(Thread* t, object this_, const char* spec,
   }
 }
 
-void
-pushArguments(Thread* t, object this_, const char* spec, object a)
+void pushArguments(Thread* t, object this_, const char* spec, object a)
 {
   if (this_) {
     pushObject(t, this_);
@@ -2891,8 +3104,9 @@ pushArguments(Thread* t, object this_, const char* spec, object a)
       break;
 
     default:
-      pushInt(t, fieldAtOffset<int32_t>(objectArrayBody(t, a, index++),
-                               BytesPerWord));
+      pushInt(
+          t,
+          fieldAtOffset<int32_t>(objectArrayBody(t, a, index++), BytesPerWord));
       break;
     }
   }
@@ -2975,7 +3189,7 @@ object invoke(Thread* t, GcMethod* method)
   return result;
 }
 
-class MyProcessor: public Processor {
+class MyProcessor : public Processor {
  public:
   MyProcessor(System* s, Allocator* allocator, const char* crashDumpDirectory)
       : s(s), allocator(allocator)
@@ -2988,7 +3202,7 @@ class MyProcessor: public Processor {
                                  vm::Thread* parent)
   {
     Thread* t = new (m->heap->allocate(sizeof(Thread) + m->stackSizeInBytes))
-      Thread(m, javaThread, parent);
+        Thread(m, javaThread, parent);
     t->init();
     return t;
   }
@@ -3070,8 +3284,7 @@ class MyProcessor: public Processor {
     // ignore
   }
 
-  virtual void
-  visitObjects(vm::Thread* vmt, Heap::Visitor* v)
+  virtual void visitObjects(vm::Thread* vmt, Heap::Visitor* v)
   {
     Thread* t = static_cast<Thread*>(vmt);
 
@@ -3084,8 +3297,7 @@ class MyProcessor: public Processor {
     }
   }
 
-  virtual void
-  walkStack(vm::Thread* vmt, StackVisitor* v)
+  virtual void walkStack(vm::Thread* vmt, StackVisitor* v)
   {
     Thread* t = static_cast<Thread*>(vmt);
 
@@ -3102,30 +3314,27 @@ class MyProcessor: public Processor {
     return findLineNumber(static_cast<Thread*>(t), method, ip);
   }
 
-  virtual object*
-  makeLocalReference(vm::Thread* vmt, object o)
+  virtual object* makeLocalReference(vm::Thread* vmt, object o)
   {
     Thread* t = static_cast<Thread*>(vmt);
 
     return pushReference(t, o);
   }
 
-  virtual void
-  disposeLocalReference(vm::Thread*, object* r)
+  virtual void disposeLocalReference(vm::Thread*, object* r)
   {
     if (r) {
       *r = 0;
     }
   }
 
-  virtual bool
-  pushLocalFrame(vm::Thread* vmt, unsigned capacity)
+  virtual bool pushLocalFrame(vm::Thread* vmt, unsigned capacity)
   {
     Thread* t = static_cast<Thread*>(vmt);
 
     if (t->sp + capacity < stackSizeInWords(t) / 2) {
-      t->stackPointers = new(t->m->heap)
-        List<unsigned>(t->sp, t->stackPointers);
+      t->stackPointers = new (t->m->heap)
+          List<unsigned>(t->sp, t->stackPointers);
 
       return true;
     } else {
@@ -3133,8 +3342,7 @@ class MyProcessor: public Processor {
     }
   }
 
-  virtual void
-  popLocalFrame(vm::Thread* vmt)
+  virtual void popLocalFrame(vm::Thread* vmt)
   {
     Thread* t = static_cast<Thread*>(vmt);
 
@@ -3233,8 +3441,7 @@ class MyProcessor: public Processor {
         t->state == Thread::ActiveState or t->state == Thread::ExclusiveState);
 
     if (UNLIKELY(t->sp + parameterFootprint(vmt, methodSpec, false)
-                 > stackSizeInWords(t) / 2))
-    {
+                 > stackSizeInWords(t) / 2)) {
       throwNew(t, GcStackOverflowError::Type);
     }
 
@@ -3248,7 +3455,8 @@ class MyProcessor: public Processor {
     return local::invoke(t, method);
   }
 
-  virtual object getStackTrace(vm::Thread* t, vm::Thread*) {
+  virtual object getStackTrace(vm::Thread* t, vm::Thread*)
+  {
     // not implemented
     return makeObjectArray(t, 0);
   }
@@ -3258,7 +3466,8 @@ class MyProcessor: public Processor {
     abort(s);
   }
 
-  virtual void addCompilationHandler(CompilationHandler*) {
+  virtual void addCompilationHandler(CompilationHandler*)
+  {
     abort(s);
   }
 
@@ -3273,27 +3482,33 @@ class MyProcessor: public Processor {
     abort(s);
   }
 
-  virtual void visitRoots(vm::Thread*, HeapWalker*) {
+  virtual void visitRoots(vm::Thread*, HeapWalker*)
+  {
     abort(s);
   }
 
-  virtual void normalizeVirtualThunks(vm::Thread*) {
+  virtual void normalizeVirtualThunks(vm::Thread*)
+  {
     abort(s);
   }
 
-  virtual unsigned* makeCallTable(vm::Thread*, HeapWalker*) {
+  virtual unsigned* makeCallTable(vm::Thread*, HeapWalker*)
+  {
     abort(s);
   }
 
-  virtual void boot(vm::Thread*, BootImage* image, uint8_t* code) {
+  virtual void boot(vm::Thread*, BootImage* image, uint8_t* code)
+  {
     expect(s, image == 0 and code == 0);
   }
 
-  virtual void callWithCurrentContinuation(vm::Thread*, object) {
+  virtual void callWithCurrentContinuation(vm::Thread*, object)
+  {
     abort(s);
   }
 
-  virtual void dynamicWind(vm::Thread*, object, object, object) {
+  virtual void dynamicWind(vm::Thread*, object, object, object)
+  {
     abort(s);
   }
 
@@ -3309,17 +3524,21 @@ class MyProcessor: public Processor {
     abort(s);
   }
 
-  virtual void walkContinuationBody(vm::Thread*, Heap::Walker*, object,
+  virtual void walkContinuationBody(vm::Thread*,
+                                    Heap::Walker*,
+                                    object,
                                     unsigned)
   {
     abort(s);
   }
 
-  virtual void dispose(vm::Thread* t) {
+  virtual void dispose(vm::Thread* t)
+  {
     t->m->heap->free(t, sizeof(Thread) + t->m->stackSizeInBytes);
   }
 
-  virtual void dispose() {
+  virtual void dispose()
+  {
     signals.setCrashDumpDirectory(0);
     this->~MyProcessor();
     allocator->free(this, sizeof(*this));
@@ -3330,7 +3549,7 @@ class MyProcessor: public Processor {
   SignalRegistrar signals;
 };
 
-} // namespace
+}  // namespace
 
 namespace vm {
 
@@ -3340,7 +3559,7 @@ Processor* makeProcessor(System* system,
                          bool)
 {
   return new (allocator->allocate(sizeof(local::MyProcessor)))
-    local::MyProcessor(system, allocator, crashDumpDirectory);
+      local::MyProcessor(system, allocator, crashDumpDirectory);
 }
 
-} // namespace vm
+}  // namespace vm
diff --git a/src/jnienv.cpp b/src/jnienv.cpp
index 5cda26824c..58089d1e62 100644
--- a/src/jnienv.cpp
+++ b/src/jnienv.cpp
@@ -22,8 +22,7 @@ namespace {
 
 namespace local {
 
-jint JNICALL
-AttachCurrentThread(Machine* m, Thread** t, void*)
+jint JNICALL AttachCurrentThread(Machine* m, Thread** t, void*)
 {
   *t = static_cast<Thread*>(m->localThread->get());
   if (*t == 0) {
@@ -32,8 +31,7 @@ AttachCurrentThread(Machine* m, Thread** t, void*)
   return 0;
 }
 
-jint JNICALL
-AttachCurrentThreadAsDaemon(Machine* m, Thread** t, void*)
+jint JNICALL AttachCurrentThreadAsDaemon(Machine* m, Thread** t, void*)
 {
   *t = static_cast<Thread*>(m->localThread->get());
   if (*t == 0) {
@@ -42,8 +40,7 @@ AttachCurrentThreadAsDaemon(Machine* m, Thread** t, void*)
   return 0;
 }
 
-jint JNICALL
-DetachCurrentThread(Machine* m)
+jint JNICALL DetachCurrentThread(Machine* m)
 {
   Thread* t = static_cast<Thread*>(m->localThread->get());
   if (t) {
@@ -71,24 +68,26 @@ DetachCurrentThread(Machine* m)
   }
 }
 
-uint64_t
-destroyJavaVM(Thread* t, uintptr_t*)
+uint64_t destroyJavaVM(Thread* t, uintptr_t*)
 {
   // wait for other non-daemon threads to exit
-  { ACQUIRE(t, t->m->stateLock);
+  {
+    ACQUIRE(t, t->m->stateLock);
     while (t->m->liveCount - t->m->daemonCount > 1) {
       t->m->stateLock->wait(t->systemThread, 0);
     }
   }
 
-  { ENTER(t, Thread::ActiveState);
+  {
+    ENTER(t, Thread::ActiveState);
 
     t->m->classpath->shutDown(t);
   }
 
   // wait again in case the Classpath::shutDown process started new
   // threads:
-  { ACQUIRE(t, t->m->stateLock);
+  {
+    ACQUIRE(t, t->m->stateLock);
     while (t->m->liveCount - t->m->daemonCount > 1) {
       t->m->stateLock->wait(t->systemThread, 0);
     }
@@ -101,10 +100,10 @@ destroyJavaVM(Thread* t, uintptr_t*)
   return 1;
 }
 
-jint JNICALL
-DestroyJavaVM(Machine* m)
+jint JNICALL DestroyJavaVM(Machine* m)
 {
-  Thread* t; AttachCurrentThread(m, &t, 0);
+  Thread* t;
+  AttachCurrentThread(m, &t, 0);
 
   if (runRaw(t, destroyJavaVM, 0)) {
     t->exit();
@@ -114,8 +113,7 @@ DestroyJavaVM(Machine* m)
   }
 }
 
-jint JNICALL
-GetEnv(Machine* m, Thread** t, jint version)
+jint JNICALL GetEnv(Machine* m, Thread** t, jint version)
 {
   *t = static_cast<Thread*>(m->localThread->get());
   if (*t) {
@@ -129,24 +127,21 @@ GetEnv(Machine* m, Thread** t, jint version)
   }
 }
 
-jint JNICALL
-GetVersion(Thread* t)
+jint JNICALL GetVersion(Thread* t)
 {
   ENTER(t, Thread::ActiveState);
 
   return JNI_VERSION_1_6;
 }
 
-jsize JNICALL
-GetStringLength(Thread* t, jstring s)
+jsize JNICALL GetStringLength(Thread* t, jstring s)
 {
   ENTER(t, Thread::ActiveState);
 
   return (*s)->length(t);
 }
 
-const jchar* JNICALL
-GetStringChars(Thread* t, jstring s, jboolean* isCopy)
+const jchar* JNICALL GetStringChars(Thread* t, jstring s, jboolean* isCopy)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -154,12 +149,12 @@ GetStringChars(Thread* t, jstring s, jboolean* isCopy)
       t->m->heap->allocate(((*s)->length(t) + 1) * sizeof(jchar)));
   stringChars(t, *s, chars);
 
-  if (isCopy) *isCopy = true;
+  if (isCopy)
+    *isCopy = true;
   return chars;
 }
 
-void JNICALL
-ReleaseStringChars(Thread* t, jstring s, const jchar* chars)
+void JNICALL ReleaseStringChars(Thread* t, jstring s, const jchar* chars)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -167,21 +162,20 @@ ReleaseStringChars(Thread* t, jstring s, const jchar* chars)
 }
 
 void JNICALL
-GetStringRegion(Thread* t, jstring s, jsize start, jsize length, jchar* dst)
+    GetStringRegion(Thread* t, jstring s, jsize start, jsize length, jchar* dst)
 {
   ENTER(t, Thread::ActiveState);
 
   stringChars(t, *s, start, length, dst);
 }
 
-const jchar* JNICALL
-GetStringCritical(Thread* t, jstring s, jboolean* isCopy)
+const jchar* JNICALL GetStringCritical(Thread* t, jstring s, jboolean* isCopy)
 {
   if (t->criticalLevel == 0) {
     enter(t, Thread::ActiveState);
   }
 
-  ++ t->criticalLevel;
+  ++t->criticalLevel;
 
   if (isCopy) {
     *isCopy = true;
@@ -195,67 +189,64 @@ GetStringCritical(Thread* t, jstring s, jboolean* isCopy)
   }
 }
 
-void JNICALL
-ReleaseStringCritical(Thread* t, jstring s, const jchar* chars)
+void JNICALL ReleaseStringCritical(Thread* t, jstring s, const jchar* chars)
 {
   if (objectClass(t, (*s)->data()) == type(t, GcByteArray::Type)) {
     ReleaseStringChars(t, s, chars);
   }
 
-  if ((-- t->criticalLevel) == 0) {
+  if ((--t->criticalLevel) == 0) {
     enter(t, Thread::IdleState);
   }
 }
 
-jsize JNICALL
-GetStringUTFLength(Thread* t, jstring s)
+jsize JNICALL GetStringUTFLength(Thread* t, jstring s)
 {
   ENTER(t, Thread::ActiveState);
 
   return stringUTFLength(t, *s);
 }
 
-const char* JNICALL
-GetStringUTFChars(Thread* t, jstring s, jboolean* isCopy)
+const char* JNICALL GetStringUTFChars(Thread* t, jstring s, jboolean* isCopy)
 {
   ENTER(t, Thread::ActiveState);
 
   int length = stringUTFLength(t, *s);
-  char* chars = static_cast<char*>
-    (t->m->heap->allocate(length + 1));
+  char* chars = static_cast<char*>(t->m->heap->allocate(length + 1));
   stringUTFChars(t, *s, chars, length);
 
-  if (isCopy) *isCopy = true;
+  if (isCopy)
+    *isCopy = true;
   return chars;
 }
 
-void JNICALL
-ReleaseStringUTFChars(Thread* t, jstring s, const char* chars)
+void JNICALL ReleaseStringUTFChars(Thread* t, jstring s, const char* chars)
 {
   ENTER(t, Thread::ActiveState);
 
   t->m->heap->free(chars, stringUTFLength(t, *s) + 1);
 }
 
-void JNICALL
-GetStringUTFRegion(Thread* t, jstring s, jsize start, jsize length, char* dst)
+void JNICALL GetStringUTFRegion(Thread* t,
+                                jstring s,
+                                jsize start,
+                                jsize length,
+                                char* dst)
 {
   ENTER(t, Thread::ActiveState);
 
-  stringUTFChars
-    (t, *s, start, length, dst, stringUTFLength(t, *s, start, length));
+  stringUTFChars(
+      t, *s, start, length, dst, stringUTFLength(t, *s, start, length));
 }
 
-jsize JNICALL
-GetArrayLength(Thread* t, jarray array)
+jsize JNICALL GetArrayLength(Thread* t, jarray array)
 {
   ENTER(t, Thread::ActiveState);
 
   return fieldAtOffset<uintptr_t>(*array, BytesPerWord);
 }
 
-uint64_t
-newString(Thread* t, uintptr_t* arguments)
+uint64_t newString(Thread* t, uintptr_t* arguments)
 {
   const jchar* chars = reinterpret_cast<const jchar*>(arguments[0]);
   jsize size = arguments[1];
@@ -269,53 +260,50 @@ newString(Thread* t, uintptr_t* arguments)
       makeLocalReference(t, t->m->classpath->makeString(t, a, 0, size)));
 }
 
-jstring JNICALL
-NewString(Thread* t, const jchar* chars, jsize size)
+jstring JNICALL NewString(Thread* t, const jchar* chars, jsize size)
 {
-  if (chars == 0) return 0;
+  if (chars == 0)
+    return 0;
 
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(chars),
-                            static_cast<uintptr_t>(size) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(chars), static_cast<uintptr_t>(size)};
 
   return reinterpret_cast<jstring>(run(t, newString, arguments));
 }
 
-uint64_t
-newStringUTF(Thread* t, uintptr_t* arguments)
+uint64_t newStringUTF(Thread* t, uintptr_t* arguments)
 {
   const char* chars = reinterpret_cast<const char*>(arguments[0]);
 
   object array = parseUtf8(t, chars, strlen(chars));
 
-  return reinterpret_cast<uint64_t>
-    (makeLocalReference
-     (t, t->m->classpath->makeString
-      (t, array, 0, fieldAtOffset<uintptr_t>(array, BytesPerWord) - 1)));
+  return reinterpret_cast<uint64_t>(makeLocalReference(
+      t,
+      t->m->classpath->makeString(
+          t, array, 0, fieldAtOffset<uintptr_t>(array, BytesPerWord) - 1)));
 }
 
-jstring JNICALL
-NewStringUTF(Thread* t, const char* chars)
+jstring JNICALL NewStringUTF(Thread* t, const char* chars)
 {
-  if (chars == 0) return 0;
+  if (chars == 0)
+    return 0;
 
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(chars) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(chars)};
 
   return reinterpret_cast<jstring>(run(t, newStringUTF, arguments));
 }
 
-void
-replace(int a, int b, const char* in, int8_t* out)
+void replace(int a, int b, const char* in, int8_t* out)
 {
   while (*in) {
     *out = (*in == a ? b : *in);
-    ++ in;
-    ++ out;
+    ++in;
+    ++out;
   }
   *out = 0;
 }
 
-uint64_t
-defineClass(Thread* t, uintptr_t* arguments)
+uint64_t defineClass(Thread* t, uintptr_t* arguments)
 {
   jobject loader = reinterpret_cast<jobject>(arguments[0]);
   const uint8_t* buffer = reinterpret_cast<const uint8_t*>(arguments[1]);
@@ -333,19 +321,20 @@ defineClass(Thread* t, uintptr_t* arguments)
                                     length)))));
 }
 
-jclass JNICALL
-DefineClass(Thread* t, const char*, jobject loader, const jbyte* buffer,
-            jsize length)
+jclass JNICALL DefineClass(Thread* t,
+                           const char*,
+                           jobject loader,
+                           const jbyte* buffer,
+                           jsize length)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(loader),
-                            reinterpret_cast<uintptr_t>(buffer),
-                            static_cast<uintptr_t>(length) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(loader),
+                           reinterpret_cast<uintptr_t>(buffer),
+                           static_cast<uintptr_t>(length)};
 
   return reinterpret_cast<jclass>(run(t, defineClass, arguments));
 }
 
-uint64_t
-findClass(Thread* t, uintptr_t* arguments)
+uint64_t findClass(Thread* t, uintptr_t* arguments)
 {
   const char* name = reinterpret_cast<const char*>(arguments[0]);
 
@@ -369,16 +358,14 @@ findClass(Thread* t, uintptr_t* arguments)
   return reinterpret_cast<uint64_t>(makeLocalReference(t, getJClass(t, c)));
 }
 
-jclass JNICALL
-FindClass(Thread* t, const char* name)
+jclass JNICALL FindClass(Thread* t, const char* name)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(name) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(name)};
 
   return reinterpret_cast<jclass>(run(t, findClass, arguments));
 }
 
-uint64_t
-throwNew(Thread* t, uintptr_t* arguments)
+uint64_t throwNew(Thread* t, uintptr_t* arguments)
 {
   jclass c = reinterpret_cast<jclass>(arguments[0]);
   const char* message = reinterpret_cast<const char*>(arguments[1]);
@@ -400,21 +387,19 @@ throwNew(Thread* t, uintptr_t* arguments)
   return 1;
 }
 
-jint JNICALL
-ThrowNew(Thread* t, jclass c, const char* message)
+jint JNICALL ThrowNew(Thread* t, jclass c, const char* message)
 {
   if (t->exception) {
     return -1;
   }
 
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            reinterpret_cast<uintptr_t>(message) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(c), reinterpret_cast<uintptr_t>(message)};
 
   return run(t, throwNew, arguments) ? 0 : -1;
 }
 
-jint JNICALL
-Throw(Thread* t, jthrowable throwable)
+jint JNICALL Throw(Thread* t, jthrowable throwable)
 {
   if (t->exception) {
     return -1;
@@ -427,30 +412,26 @@ Throw(Thread* t, jthrowable throwable)
   return 0;
 }
 
-jobject JNICALL
-NewLocalRef(Thread* t, jobject o)
+jobject JNICALL NewLocalRef(Thread* t, jobject o)
 {
   ENTER(t, Thread::ActiveState);
 
   return makeLocalReference(t, *o);
 }
 
-void JNICALL
-DeleteLocalRef(Thread* t, jobject r)
+void JNICALL DeleteLocalRef(Thread* t, jobject r)
 {
   ENTER(t, Thread::ActiveState);
 
   disposeLocalReference(t, r);
 }
 
-jboolean JNICALL
-ExceptionCheck(Thread* t)
+jboolean JNICALL ExceptionCheck(Thread* t)
 {
   return t->exception != 0;
 }
 
-uint64_t
-getObjectClass(Thread* t, uintptr_t* arguments)
+uint64_t getObjectClass(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
 
@@ -458,37 +439,34 @@ getObjectClass(Thread* t, uintptr_t* arguments)
       makeLocalReference(t, getJClass(t, objectClass(t, *o))));
 }
 
-jclass JNICALL
-GetObjectClass(Thread* t, jobject o)
+jclass JNICALL GetObjectClass(Thread* t, jobject o)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o)};
 
   return reinterpret_cast<jclass>(run(t, getObjectClass, arguments));
 }
 
-uint64_t
-getSuperclass(Thread* t, uintptr_t* arguments)
+uint64_t getSuperclass(Thread* t, uintptr_t* arguments)
 {
   GcClass* class_ = (*reinterpret_cast<jclass>(arguments[0]))->vmClass();
   if (class_->flags() & ACC_INTERFACE) {
     return 0;
   } else {
     GcClass* super = class_->super();
-    return super ? reinterpret_cast<uint64_t>
-      (makeLocalReference(t, getJClass(t, super))) : 0;
+    return super ? reinterpret_cast<uint64_t>(
+                       makeLocalReference(t, getJClass(t, super)))
+                 : 0;
   }
 }
 
-jclass JNICALL
-GetSuperclass(Thread* t, jclass c)
+jclass JNICALL GetSuperclass(Thread* t, jclass c)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c)};
 
   return reinterpret_cast<jclass>(run(t, getSuperclass, arguments));
 }
 
-uint64_t
-isInstanceOf(Thread* t, uintptr_t* arguments)
+uint64_t isInstanceOf(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   jclass c = reinterpret_cast<jclass>(arguments[1]);
@@ -496,17 +474,15 @@ isInstanceOf(Thread* t, uintptr_t* arguments)
   return instanceOf(t, (*c)->vmClass(), *o);
 }
 
-jboolean JNICALL
-IsInstanceOf(Thread* t, jobject o, jclass c)
+jboolean JNICALL IsInstanceOf(Thread* t, jobject o, jclass c)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            reinterpret_cast<uintptr_t>(c) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(o), reinterpret_cast<uintptr_t>(c)};
 
   return run(t, isInstanceOf, arguments);
 }
 
-uint64_t
-isAssignableFrom(Thread* t, uintptr_t* arguments)
+uint64_t isAssignableFrom(Thread* t, uintptr_t* arguments)
 {
   jclass b = reinterpret_cast<jclass>(arguments[0]);
   jclass a = reinterpret_cast<jclass>(arguments[1]);
@@ -514,11 +490,10 @@ isAssignableFrom(Thread* t, uintptr_t* arguments)
   return isAssignableFrom(t, (*a)->vmClass(), (*b)->vmClass());
 }
 
-jboolean JNICALL
-IsAssignableFrom(Thread* t, jclass b, jclass a)
+jboolean JNICALL IsAssignableFrom(Thread* t, jclass b, jclass a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(b),
-                            reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(b), reinterpret_cast<uintptr_t>(a)};
 
   return run(t, isAssignableFrom, arguments);
 }
@@ -557,8 +532,7 @@ jint methodID(Thread* t, GcMethod* method)
   return method->nativeID();
 }
 
-uint64_t
-getMethodID(Thread* t, uintptr_t* arguments)
+uint64_t getMethodID(Thread* t, uintptr_t* arguments)
 {
   jclass c = reinterpret_cast<jclass>(arguments[0]);
   const char* name = reinterpret_cast<const char*>(arguments[1]);
@@ -572,17 +546,16 @@ getMethodID(Thread* t, uintptr_t* arguments)
 }
 
 jmethodID JNICALL
-GetMethodID(Thread* t, jclass c, const char* name, const char* spec)
+    GetMethodID(Thread* t, jclass c, const char* name, const char* spec)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            reinterpret_cast<uintptr_t>(name),
-                            reinterpret_cast<uintptr_t>(spec) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c),
+                           reinterpret_cast<uintptr_t>(name),
+                           reinterpret_cast<uintptr_t>(spec)};
 
   return run(t, getMethodID, arguments);
 }
 
-uint64_t
-getStaticMethodID(Thread* t, uintptr_t* arguments)
+uint64_t getStaticMethodID(Thread* t, uintptr_t* arguments)
 {
   jclass c = reinterpret_cast<jclass>(arguments[0]);
   const char* name = reinterpret_cast<const char*>(arguments[1]);
@@ -596,11 +569,11 @@ getStaticMethodID(Thread* t, uintptr_t* arguments)
 }
 
 jmethodID JNICALL
-GetStaticMethodID(Thread* t, jclass c, const char* name, const char* spec)
+    GetStaticMethodID(Thread* t, jclass c, const char* name, const char* spec)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            reinterpret_cast<uintptr_t>(name),
-                            reinterpret_cast<uintptr_t>(spec) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c),
+                           reinterpret_cast<uintptr_t>(name),
+                           reinterpret_cast<uintptr_t>(spec)};
 
   return run(t, getStaticMethodID, arguments);
 }
@@ -617,8 +590,7 @@ GcMethod* getMethod(Thread* t, jmethodID m)
   return method;
 }
 
-uint64_t
-newObjectV(Thread* t, uintptr_t* arguments)
+uint64_t newObjectV(Thread* t, uintptr_t* arguments)
 {
   jclass c = reinterpret_cast<jclass>(arguments[0]);
   jmethodID m = arguments[1];
@@ -632,18 +604,16 @@ newObjectV(Thread* t, uintptr_t* arguments)
   return reinterpret_cast<uint64_t>(makeLocalReference(t, o));
 }
 
-jobject JNICALL
-NewObjectV(Thread* t, jclass c, jmethodID m, va_list a)
+jobject JNICALL NewObjectV(Thread* t, jclass c, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            m,
-                            reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c),
+                           m,
+                           reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return reinterpret_cast<jobject>(run(t, newObjectV, arguments));
 }
 
-jobject JNICALL
-NewObject(Thread* t, jclass c, jmethodID m, ...)
+jobject JNICALL NewObject(Thread* t, jclass c, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -655,8 +625,7 @@ NewObject(Thread* t, jclass c, jmethodID m, ...)
   return r;
 }
 
-uint64_t
-newObjectA(Thread* t, uintptr_t* arguments)
+uint64_t newObjectA(Thread* t, uintptr_t* arguments)
 {
   jclass c = reinterpret_cast<jclass>(arguments[0]);
   jmethodID m = arguments[1];
@@ -678,30 +647,26 @@ jobject JNICALL NewObjectA(Thread* t, jclass c, jmethodID m, const jvalue* a)
   return reinterpret_cast<jobject>(run(t, newObjectA, arguments));
 }
 
-uint64_t
-callObjectMethodV(Thread* t, uintptr_t* arguments)
+uint64_t callObjectMethodV(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   jmethodID m = arguments[1];
   va_list* a = reinterpret_cast<va_list*>(arguments[2]);
 
-  return reinterpret_cast<uint64_t>
-    (makeLocalReference
-     (t, t->m->processor->invokeList(t, getMethod(t, m), *o, true, *a)));
+  return reinterpret_cast<uint64_t>(makeLocalReference(
+      t, t->m->processor->invokeList(t, getMethod(t, m), *o, true, *a)));
 }
 
-jobject JNICALL
-CallObjectMethodV(Thread* t, jobject o, jmethodID m, va_list a)
+jobject JNICALL CallObjectMethodV(Thread* t, jobject o, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o),
+                           m,
+                           reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return reinterpret_cast<jobject>(run(t, callObjectMethodV, arguments));
 }
 
-jobject JNICALL
-CallObjectMethod(Thread* t, jobject o, jmethodID m, ...)
+jobject JNICALL CallObjectMethod(Thread* t, jobject o, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -713,30 +678,26 @@ CallObjectMethod(Thread* t, jobject o, jmethodID m, ...)
   return r;
 }
 
-uint64_t
-callObjectMethodA(Thread* t, uintptr_t* arguments)
+uint64_t callObjectMethodA(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   jmethodID m = arguments[1];
   const jvalue* a = reinterpret_cast<const jvalue*>(arguments[2]);
 
-  return reinterpret_cast<uint64_t>
-    (makeLocalReference
-     (t, t->m->processor->invokeArray(t, getMethod(t, m), *o, a)));
+  return reinterpret_cast<uint64_t>(makeLocalReference(
+      t, t->m->processor->invokeArray(t, getMethod(t, m), *o, a)));
 }
 
 jobject JNICALL
-CallObjectMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
+    CallObjectMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(o), m, reinterpret_cast<uintptr_t>(a)};
 
   return reinterpret_cast<jobject>(run(t, callObjectMethodA, arguments));
 }
 
-uint64_t
-callIntMethodV(Thread* t, uintptr_t* arguments)
+uint64_t callIntMethodV(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   jmethodID m = arguments[1];
@@ -748,17 +709,16 @@ callIntMethodV(Thread* t, uintptr_t* arguments)
 }
 
 jboolean JNICALL
-CallBooleanMethodV(Thread* t, jobject o, jmethodID m, va_list a)
+    CallBooleanMethodV(Thread* t, jobject o, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o),
+                           m,
+                           reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return run(t, callIntMethodV, arguments) != 0;
 }
 
-jboolean JNICALL
-CallBooleanMethod(Thread* t, jobject o, jmethodID m, ...)
+jboolean JNICALL CallBooleanMethod(Thread* t, jobject o, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -770,8 +730,7 @@ CallBooleanMethod(Thread* t, jobject o, jmethodID m, ...)
   return r;
 }
 
-uint64_t
-callIntMethodA(Thread* t, uintptr_t* arguments)
+uint64_t callIntMethodA(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   jmethodID m = arguments[1];
@@ -782,27 +741,24 @@ callIntMethodA(Thread* t, uintptr_t* arguments)
 }
 
 jboolean JNICALL
-CallBooleanMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
+    CallBooleanMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(o), m, reinterpret_cast<uintptr_t>(a)};
 
   return run(t, callIntMethodA, arguments) != 0;
 }
 
-jbyte JNICALL
-CallByteMethodV(Thread* t, jobject o, jmethodID m, va_list a)
+jbyte JNICALL CallByteMethodV(Thread* t, jobject o, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o),
+                           m,
+                           reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return run(t, callIntMethodV, arguments);
 }
 
-jbyte JNICALL
-CallByteMethod(Thread* t, jobject o, jmethodID m, ...)
+jbyte JNICALL CallByteMethod(Thread* t, jobject o, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -815,27 +771,24 @@ CallByteMethod(Thread* t, jobject o, jmethodID m, ...)
 }
 
 jbyte JNICALL
-CallByteMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
+    CallByteMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(o), m, reinterpret_cast<uintptr_t>(a)};
 
   return run(t, callIntMethodA, arguments);
 }
 
-jchar JNICALL
-CallCharMethodV(Thread* t, jobject o, jmethodID m, va_list a)
+jchar JNICALL CallCharMethodV(Thread* t, jobject o, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o),
+                           m,
+                           reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return run(t, callIntMethodV, arguments);
 }
 
-jchar JNICALL
-CallCharMethod(Thread* t, jobject o, jmethodID m, ...)
+jchar JNICALL CallCharMethod(Thread* t, jobject o, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -848,27 +801,24 @@ CallCharMethod(Thread* t, jobject o, jmethodID m, ...)
 }
 
 jchar JNICALL
-CallCharMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
+    CallCharMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(o), m, reinterpret_cast<uintptr_t>(a)};
 
   return run(t, callIntMethodA, arguments);
 }
 
-jshort JNICALL
-CallShortMethodV(Thread* t, jobject o, jmethodID m, va_list a)
+jshort JNICALL CallShortMethodV(Thread* t, jobject o, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o),
+                           m,
+                           reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return run(t, callIntMethodV, arguments);
 }
 
-jshort JNICALL
-CallShortMethod(Thread* t, jobject o, jmethodID m, ...)
+jshort JNICALL CallShortMethod(Thread* t, jobject o, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -881,27 +831,24 @@ CallShortMethod(Thread* t, jobject o, jmethodID m, ...)
 }
 
 jshort JNICALL
-CallShortMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
+    CallShortMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(o), m, reinterpret_cast<uintptr_t>(a)};
 
   return run(t, callIntMethodA, arguments);
 }
 
-jint JNICALL
-CallIntMethodV(Thread* t, jobject o, jmethodID m, va_list a)
+jint JNICALL CallIntMethodV(Thread* t, jobject o, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o),
+                           m,
+                           reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return run(t, callIntMethodV, arguments);
 }
 
-jint JNICALL
-CallIntMethod(Thread* t, jobject o, jmethodID m, ...)
+jint JNICALL CallIntMethod(Thread* t, jobject o, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -913,18 +860,15 @@ CallIntMethod(Thread* t, jobject o, jmethodID m, ...)
   return r;
 }
 
-jint JNICALL
-CallIntMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
+jint JNICALL CallIntMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(o), m, reinterpret_cast<uintptr_t>(a)};
 
   return run(t, callIntMethodA, arguments);
 }
 
-uint64_t
-callLongMethodV(Thread* t, uintptr_t* arguments)
+uint64_t callLongMethodV(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   jmethodID m = arguments[1];
@@ -935,18 +879,16 @@ callLongMethodV(Thread* t, uintptr_t* arguments)
       ->value();
 }
 
-jlong JNICALL
-CallLongMethodV(Thread* t, jobject o, jmethodID m, va_list a)
+jlong JNICALL CallLongMethodV(Thread* t, jobject o, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o),
+                           m,
+                           reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return run(t, callLongMethodV, arguments);
 }
 
-jlong JNICALL
-CallLongMethod(Thread* t, jobject o, jmethodID m, ...)
+jlong JNICALL CallLongMethod(Thread* t, jobject o, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -958,8 +900,7 @@ CallLongMethod(Thread* t, jobject o, jmethodID m, ...)
   return r;
 }
 
-uint64_t
-callLongMethodA(Thread* t, uintptr_t* arguments)
+uint64_t callLongMethodA(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   jmethodID m = arguments[1];
@@ -971,27 +912,24 @@ callLongMethodA(Thread* t, uintptr_t* arguments)
 }
 
 jlong JNICALL
-CallLongMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
+    CallLongMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(o), m, reinterpret_cast<uintptr_t>(a)};
 
   return run(t, callLongMethodA, arguments);
 }
 
-jfloat JNICALL
-CallFloatMethodV(Thread* t, jobject o, jmethodID m, va_list a)
+jfloat JNICALL CallFloatMethodV(Thread* t, jobject o, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o),
+                           m,
+                           reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return bitsToFloat(run(t, callIntMethodV, arguments));
 }
 
-jfloat JNICALL
-CallFloatMethod(Thread* t, jobject o, jmethodID m, ...)
+jfloat JNICALL CallFloatMethod(Thread* t, jobject o, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -1004,27 +942,24 @@ CallFloatMethod(Thread* t, jobject o, jmethodID m, ...)
 }
 
 jfloat JNICALL
-CallFloatMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
+    CallFloatMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(o), m, reinterpret_cast<uintptr_t>(a)};
 
   return bitsToFloat(run(t, callIntMethodA, arguments));
 }
 
-jdouble JNICALL
-CallDoubleMethodV(Thread* t, jobject o, jmethodID m, va_list a)
+jdouble JNICALL CallDoubleMethodV(Thread* t, jobject o, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o),
+                           m,
+                           reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return bitsToDouble(run(t, callLongMethodV, arguments));
 }
 
-jdouble JNICALL
-CallDoubleMethod(Thread* t, jobject o, jmethodID m, ...)
+jdouble JNICALL CallDoubleMethod(Thread* t, jobject o, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -1037,17 +972,15 @@ CallDoubleMethod(Thread* t, jobject o, jmethodID m, ...)
 }
 
 jdouble JNICALL
-CallDoubleMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
+    CallDoubleMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(o), m, reinterpret_cast<uintptr_t>(a)};
 
   return bitsToDouble(run(t, callLongMethodA, arguments));
 }
 
-uint64_t
-callVoidMethodV(Thread* t, uintptr_t* arguments)
+uint64_t callVoidMethodV(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   jmethodID m = arguments[1];
@@ -1058,18 +991,16 @@ callVoidMethodV(Thread* t, uintptr_t* arguments)
   return 0;
 }
 
-void JNICALL
-CallVoidMethodV(Thread* t, jobject o, jmethodID m, va_list a)
+void JNICALL CallVoidMethodV(Thread* t, jobject o, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o),
+                           m,
+                           reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   run(t, callVoidMethodV, arguments);
 }
 
-void JNICALL
-CallVoidMethod(Thread* t, jobject o, jmethodID m, ...)
+void JNICALL CallVoidMethod(Thread* t, jobject o, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -1079,8 +1010,7 @@ CallVoidMethod(Thread* t, jobject o, jmethodID m, ...)
   va_end(a);
 }
 
-uint64_t
-callVoidMethodA(Thread* t, uintptr_t* arguments)
+uint64_t callVoidMethodA(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   jmethodID m = arguments[1];
@@ -1091,12 +1021,10 @@ callVoidMethodA(Thread* t, uintptr_t* arguments)
   return 0;
 }
 
-void JNICALL
-CallVoidMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
+void JNICALL CallVoidMethodA(Thread* t, jobject o, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            m,
-                            reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(o), m, reinterpret_cast<uintptr_t>(a)};
 
   run(t, callVoidMethodA, arguments);
 }
@@ -1113,27 +1041,24 @@ GcMethod* getStaticMethod(Thread* t, jmethodID m)
   return method;
 }
 
-uint64_t
-callStaticObjectMethodV(Thread* t, uintptr_t* arguments)
+uint64_t callStaticObjectMethodV(Thread* t, uintptr_t* arguments)
 {
   jmethodID m = arguments[0];
   va_list* a = reinterpret_cast<va_list*>(arguments[1]);
 
-  return reinterpret_cast<uint64_t>
-    (makeLocalReference
-     (t, t->m->processor->invokeList(t, getStaticMethod(t, m), 0, true, *a)));
+  return reinterpret_cast<uint64_t>(makeLocalReference(
+      t, t->m->processor->invokeList(t, getStaticMethod(t, m), 0, true, *a)));
 }
 
 jobject JNICALL
-CallStaticObjectMethodV(Thread* t, jclass, jmethodID m, va_list a)
+    CallStaticObjectMethodV(Thread* t, jclass, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return reinterpret_cast<jobject>(run(t, callStaticObjectMethodV, arguments));
 }
 
-jobject JNICALL
-CallStaticObjectMethod(Thread* t, jclass c, jmethodID m, ...)
+jobject JNICALL CallStaticObjectMethod(Thread* t, jclass c, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -1145,27 +1070,24 @@ CallStaticObjectMethod(Thread* t, jclass c, jmethodID m, ...)
   return r;
 }
 
-uint64_t
-callStaticObjectMethodA(Thread* t, uintptr_t* arguments)
+uint64_t callStaticObjectMethodA(Thread* t, uintptr_t* arguments)
 {
   jmethodID m = arguments[0];
   const jvalue* a = reinterpret_cast<const jvalue*>(arguments[1]);
 
-  return reinterpret_cast<uint64_t>
-    (makeLocalReference
-     (t, t->m->processor->invokeArray(t, getStaticMethod(t, m), 0, a)));
+  return reinterpret_cast<uint64_t>(makeLocalReference(
+      t, t->m->processor->invokeArray(t, getStaticMethod(t, m), 0, a)));
 }
 
 jobject JNICALL
-CallStaticObjectMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
+    CallStaticObjectMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(a)};
 
   return reinterpret_cast<jobject>(run(t, callStaticObjectMethodA, arguments));
 }
 
-uint64_t
-callStaticIntMethodV(Thread* t, uintptr_t* arguments)
+uint64_t callStaticIntMethodV(Thread* t, uintptr_t* arguments)
 {
   jmethodID m = arguments[0];
   va_list* a = reinterpret_cast<va_list*>(arguments[1]);
@@ -1176,15 +1098,14 @@ callStaticIntMethodV(Thread* t, uintptr_t* arguments)
 }
 
 jboolean JNICALL
-CallStaticBooleanMethodV(Thread* t, jclass, jmethodID m, va_list a)
+    CallStaticBooleanMethodV(Thread* t, jclass, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return run(t, callStaticIntMethodV, arguments) != 0;
 }
 
-jboolean JNICALL
-CallStaticBooleanMethod(Thread* t, jclass c, jmethodID m, ...)
+jboolean JNICALL CallStaticBooleanMethod(Thread* t, jclass c, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -1196,8 +1117,7 @@ CallStaticBooleanMethod(Thread* t, jclass c, jmethodID m, ...)
   return r;
 }
 
-uint64_t
-callStaticIntMethodA(Thread* t, uintptr_t* arguments)
+uint64_t callStaticIntMethodA(Thread* t, uintptr_t* arguments)
 {
   jmethodID m = arguments[0];
   const jvalue* a = reinterpret_cast<const jvalue*>(arguments[1]);
@@ -1208,23 +1128,21 @@ callStaticIntMethodA(Thread* t, uintptr_t* arguments)
 }
 
 jboolean JNICALL
-CallStaticBooleanMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
+    CallStaticBooleanMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(a)};
 
   return run(t, callStaticIntMethodA, arguments) != 0;
 }
 
-jbyte JNICALL
-CallStaticByteMethodV(Thread* t, jclass, jmethodID m, va_list a)
+jbyte JNICALL CallStaticByteMethodV(Thread* t, jclass, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return run(t, callStaticIntMethodV, arguments);
 }
 
-jbyte JNICALL
-CallStaticByteMethod(Thread* t, jclass c, jmethodID m, ...)
+jbyte JNICALL CallStaticByteMethod(Thread* t, jclass c, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -1237,23 +1155,21 @@ CallStaticByteMethod(Thread* t, jclass c, jmethodID m, ...)
 }
 
 jbyte JNICALL
-CallStaticByteMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
+    CallStaticByteMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(a)};
 
   return run(t, callStaticIntMethodA, arguments);
 }
 
-jchar JNICALL
-CallStaticCharMethodV(Thread* t, jclass, jmethodID m, va_list a)
+jchar JNICALL CallStaticCharMethodV(Thread* t, jclass, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return run(t, callStaticIntMethodV, arguments);
 }
 
-jchar JNICALL
-CallStaticCharMethod(Thread* t, jclass c, jmethodID m, ...)
+jchar JNICALL CallStaticCharMethod(Thread* t, jclass c, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -1266,23 +1182,21 @@ CallStaticCharMethod(Thread* t, jclass c, jmethodID m, ...)
 }
 
 jchar JNICALL
-CallStaticCharMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
+    CallStaticCharMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(a)};
 
   return run(t, callStaticIntMethodA, arguments);
 }
 
-jshort JNICALL
-CallStaticShortMethodV(Thread* t, jclass, jmethodID m, va_list a)
+jshort JNICALL CallStaticShortMethodV(Thread* t, jclass, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return run(t, callStaticIntMethodV, arguments);
 }
 
-jshort JNICALL
-CallStaticShortMethod(Thread* t, jclass c, jmethodID m, ...)
+jshort JNICALL CallStaticShortMethod(Thread* t, jclass c, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -1295,23 +1209,21 @@ CallStaticShortMethod(Thread* t, jclass c, jmethodID m, ...)
 }
 
 jshort JNICALL
-CallStaticShortMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
+    CallStaticShortMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(a)};
 
   return run(t, callStaticIntMethodA, arguments);
 }
 
-jint JNICALL
-CallStaticIntMethodV(Thread* t, jclass, jmethodID m, va_list a)
+jint JNICALL CallStaticIntMethodV(Thread* t, jclass, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return run(t, callStaticIntMethodV, arguments);
 }
 
-jint JNICALL
-CallStaticIntMethod(Thread* t, jclass c, jmethodID m, ...)
+jint JNICALL CallStaticIntMethod(Thread* t, jclass c, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -1324,15 +1236,14 @@ CallStaticIntMethod(Thread* t, jclass c, jmethodID m, ...)
 }
 
 jint JNICALL
-CallStaticIntMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
+    CallStaticIntMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(a)};
 
   return run(t, callStaticIntMethodA, arguments);
 }
 
-uint64_t
-callStaticLongMethodV(Thread* t, uintptr_t* arguments)
+uint64_t callStaticLongMethodV(Thread* t, uintptr_t* arguments)
 {
   jmethodID m = arguments[0];
   va_list* a = reinterpret_cast<va_list*>(arguments[1]);
@@ -1342,16 +1253,14 @@ callStaticLongMethodV(Thread* t, uintptr_t* arguments)
                           t, getStaticMethod(t, m), 0, true, *a))->value();
 }
 
-jlong JNICALL
-CallStaticLongMethodV(Thread* t, jclass, jmethodID m, va_list a)
+jlong JNICALL CallStaticLongMethodV(Thread* t, jclass, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return run(t, callStaticLongMethodV, arguments);
 }
 
-jlong JNICALL
-CallStaticLongMethod(Thread* t, jclass c, jmethodID m, ...)
+jlong JNICALL CallStaticLongMethod(Thread* t, jclass c, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -1363,8 +1272,7 @@ CallStaticLongMethod(Thread* t, jclass c, jmethodID m, ...)
   return r;
 }
 
-uint64_t
-callStaticLongMethodA(Thread* t, uintptr_t* arguments)
+uint64_t callStaticLongMethodA(Thread* t, uintptr_t* arguments)
 {
   jmethodID m = arguments[0];
   const jvalue* a = reinterpret_cast<const jvalue*>(arguments[1]);
@@ -1375,23 +1283,21 @@ callStaticLongMethodA(Thread* t, uintptr_t* arguments)
 }
 
 jlong JNICALL
-CallStaticLongMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
+    CallStaticLongMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(a)};
 
   return run(t, callStaticLongMethodA, arguments);
 }
 
-jfloat JNICALL
-CallStaticFloatMethodV(Thread* t, jclass, jmethodID m, va_list a)
+jfloat JNICALL CallStaticFloatMethodV(Thread* t, jclass, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return bitsToFloat(run(t, callStaticIntMethodV, arguments));
 }
 
-jfloat JNICALL
-CallStaticFloatMethod(Thread* t, jclass c, jmethodID m, ...)
+jfloat JNICALL CallStaticFloatMethod(Thread* t, jclass c, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -1404,23 +1310,22 @@ CallStaticFloatMethod(Thread* t, jclass c, jmethodID m, ...)
 }
 
 jfloat JNICALL
-CallStaticFloatMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
+    CallStaticFloatMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(a)};
 
   return bitsToFloat(run(t, callStaticIntMethodA, arguments));
 }
 
 jdouble JNICALL
-CallStaticDoubleMethodV(Thread* t, jclass, jmethodID m, va_list a)
+    CallStaticDoubleMethodV(Thread* t, jclass, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   return bitsToDouble(run(t, callStaticLongMethodV, arguments));
 }
 
-jdouble JNICALL
-CallStaticDoubleMethod(Thread* t, jclass c, jmethodID m, ...)
+jdouble JNICALL CallStaticDoubleMethod(Thread* t, jclass c, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -1433,15 +1338,14 @@ CallStaticDoubleMethod(Thread* t, jclass c, jmethodID m, ...)
 }
 
 jdouble JNICALL
-CallStaticDoubleMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
+    CallStaticDoubleMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(a)};
 
   return bitsToDouble(run(t, callStaticLongMethodA, arguments));
 }
 
-uint64_t
-callStaticVoidMethodV(Thread* t, uintptr_t* arguments)
+uint64_t callStaticVoidMethodV(Thread* t, uintptr_t* arguments)
 {
   jmethodID m = arguments[0];
   va_list* a = reinterpret_cast<va_list*>(arguments[1]);
@@ -1451,16 +1355,14 @@ callStaticVoidMethodV(Thread* t, uintptr_t* arguments)
   return 0;
 }
 
-void JNICALL
-CallStaticVoidMethodV(Thread* t, jclass, jmethodID m, va_list a)
+void JNICALL CallStaticVoidMethodV(Thread* t, jclass, jmethodID m, va_list a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(VA_LIST(a)) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(VA_LIST(a))};
 
   run(t, callStaticVoidMethodV, arguments);
 }
 
-void JNICALL
-CallStaticVoidMethod(Thread* t, jclass c, jmethodID m, ...)
+void JNICALL CallStaticVoidMethod(Thread* t, jclass c, jmethodID m, ...)
 {
   va_list a;
   va_start(a, m);
@@ -1470,8 +1372,7 @@ CallStaticVoidMethod(Thread* t, jclass c, jmethodID m, ...)
   va_end(a);
 }
 
-uint64_t
-callStaticVoidMethodA(Thread* t, uintptr_t* arguments)
+uint64_t callStaticVoidMethodA(Thread* t, uintptr_t* arguments)
 {
   jmethodID m = arguments[0];
   const jvalue* a = reinterpret_cast<const jvalue*>(arguments[1]);
@@ -1482,9 +1383,9 @@ callStaticVoidMethodA(Thread* t, uintptr_t* arguments)
 }
 
 void JNICALL
-CallStaticVoidMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
+    CallStaticVoidMethodA(Thread* t, jclass, jmethodID m, const jvalue* a)
 {
-  uintptr_t arguments[] = { m, reinterpret_cast<uintptr_t>(a) };
+  uintptr_t arguments[] = {m, reinterpret_cast<uintptr_t>(a)};
 
   run(t, callStaticVoidMethodA, arguments);
 }
@@ -1514,8 +1415,7 @@ jint fieldID(Thread* t, GcField* field)
   return field->nativeID();
 }
 
-uint64_t
-getFieldID(Thread* t, uintptr_t* arguments)
+uint64_t getFieldID(Thread* t, uintptr_t* arguments)
 {
   jclass c = reinterpret_cast<jclass>(arguments[0]);
   const char* name = reinterpret_cast<const char*>(arguments[1]);
@@ -1525,21 +1425,21 @@ getFieldID(Thread* t, uintptr_t* arguments)
 }
 
 jfieldID JNICALL
-GetFieldID(Thread* t, jclass c, const char* name, const char* spec)
+    GetFieldID(Thread* t, jclass c, const char* name, const char* spec)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            reinterpret_cast<uintptr_t>(name),
-                            reinterpret_cast<uintptr_t>(spec) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c),
+                           reinterpret_cast<uintptr_t>(name),
+                           reinterpret_cast<uintptr_t>(spec)};
 
   return run(t, getFieldID, arguments);
 }
 
 jfieldID JNICALL
-GetStaticFieldID(Thread* t, jclass c, const char* name, const char* spec)
+    GetStaticFieldID(Thread* t, jclass c, const char* name, const char* spec)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            reinterpret_cast<uintptr_t>(name),
-                            reinterpret_cast<uintptr_t>(spec) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c),
+                           reinterpret_cast<uintptr_t>(name),
+                           reinterpret_cast<uintptr_t>(spec)};
 
   return run(t, getFieldID, arguments);
 }
@@ -1555,8 +1455,7 @@ GcField* getField(Thread* t, jfieldID f)
   return field;
 }
 
-uint64_t
-getObjectField(Thread* t, uintptr_t* arguments)
+uint64_t getObjectField(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   GcField* field = getField(t, arguments[1]);
@@ -1568,17 +1467,14 @@ getObjectField(Thread* t, uintptr_t* arguments)
       makeLocalReference(t, fieldAtOffset<object>(*o, field->offset())));
 }
 
-jobject JNICALL
-GetObjectField(Thread* t, jobject o, jfieldID field)
+jobject JNICALL GetObjectField(Thread* t, jobject o, jfieldID field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            field };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o), field};
 
   return reinterpret_cast<jobject>(run(t, getObjectField, arguments));
 }
 
-uint64_t
-getBooleanField(Thread* t, uintptr_t* arguments)
+uint64_t getBooleanField(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   GcField* field = getField(t, arguments[1]);
@@ -1589,17 +1485,14 @@ getBooleanField(Thread* t, uintptr_t* arguments)
   return fieldAtOffset<jboolean>(*o, field->offset());
 }
 
-jboolean JNICALL
-GetBooleanField(Thread* t, jobject o, jfieldID field)
+jboolean JNICALL GetBooleanField(Thread* t, jobject o, jfieldID field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            field };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o), field};
 
   return run(t, getBooleanField, arguments);
 }
 
-uint64_t
-getByteField(Thread* t, uintptr_t* arguments)
+uint64_t getByteField(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   GcField* field = getField(t, arguments[1]);
@@ -1610,17 +1503,14 @@ getByteField(Thread* t, uintptr_t* arguments)
   return fieldAtOffset<jbyte>(*o, field->offset());
 }
 
-jbyte JNICALL
-GetByteField(Thread* t, jobject o, jfieldID field)
+jbyte JNICALL GetByteField(Thread* t, jobject o, jfieldID field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            field };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o), field};
 
   return run(t, getByteField, arguments);
 }
 
-uint64_t
-getCharField(Thread* t, uintptr_t* arguments)
+uint64_t getCharField(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   GcField* field = getField(t, arguments[1]);
@@ -1631,17 +1521,14 @@ getCharField(Thread* t, uintptr_t* arguments)
   return fieldAtOffset<jchar>(*o, field->offset());
 }
 
-jchar JNICALL
-GetCharField(Thread* t, jobject o, jfieldID field)
+jchar JNICALL GetCharField(Thread* t, jobject o, jfieldID field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            field };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o), field};
 
   return run(t, getCharField, arguments);
 }
 
-uint64_t
-getShortField(Thread* t, uintptr_t* arguments)
+uint64_t getShortField(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   GcField* field = getField(t, arguments[1]);
@@ -1652,17 +1539,14 @@ getShortField(Thread* t, uintptr_t* arguments)
   return fieldAtOffset<jshort>(*o, field->offset());
 }
 
-jshort JNICALL
-GetShortField(Thread* t, jobject o, jfieldID field)
+jshort JNICALL GetShortField(Thread* t, jobject o, jfieldID field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            field };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o), field};
 
   return run(t, getShortField, arguments);
 }
 
-uint64_t
-getIntField(Thread* t, uintptr_t* arguments)
+uint64_t getIntField(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   GcField* field = getField(t, arguments[1]);
@@ -1673,17 +1557,14 @@ getIntField(Thread* t, uintptr_t* arguments)
   return fieldAtOffset<jint>(*o, field->offset());
 }
 
-jint JNICALL
-GetIntField(Thread* t, jobject o, jfieldID field)
+jint JNICALL GetIntField(Thread* t, jobject o, jfieldID field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            field };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o), field};
 
   return run(t, getIntField, arguments);
 }
 
-uint64_t
-getLongField(Thread* t, uintptr_t* arguments)
+uint64_t getLongField(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   GcField* field = getField(t, arguments[1]);
@@ -1694,17 +1575,14 @@ getLongField(Thread* t, uintptr_t* arguments)
   return fieldAtOffset<jlong>(*o, field->offset());
 }
 
-jlong JNICALL
-GetLongField(Thread* t, jobject o, jfieldID field)
+jlong JNICALL GetLongField(Thread* t, jobject o, jfieldID field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            field };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o), field};
 
   return run(t, getLongField, arguments);
 }
 
-uint64_t
-getFloatField(Thread* t, uintptr_t* arguments)
+uint64_t getFloatField(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   GcField* field = getField(t, arguments[1]);
@@ -1715,17 +1593,14 @@ getFloatField(Thread* t, uintptr_t* arguments)
   return floatToBits(fieldAtOffset<jfloat>(*o, field->offset()));
 }
 
-jfloat JNICALL
-GetFloatField(Thread* t, jobject o, jfieldID field)
+jfloat JNICALL GetFloatField(Thread* t, jobject o, jfieldID field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            field };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o), field};
 
   return bitsToFloat(run(t, getFloatField, arguments));
 }
 
-uint64_t
-getDoubleField(Thread* t, uintptr_t* arguments)
+uint64_t getDoubleField(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   GcField* field = getField(t, arguments[1]);
@@ -1736,17 +1611,14 @@ getDoubleField(Thread* t, uintptr_t* arguments)
   return doubleToBits(fieldAtOffset<jdouble>(*o, field->offset()));
 }
 
-jdouble JNICALL
-GetDoubleField(Thread* t, jobject o, jfieldID field)
+jdouble JNICALL GetDoubleField(Thread* t, jobject o, jfieldID field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            field };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o), field};
 
   return bitsToDouble(run(t, getDoubleField, arguments));
 }
 
-uint64_t
-setObjectField(Thread* t, uintptr_t* arguments)
+uint64_t setObjectField(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   GcField* field = getField(t, arguments[1]);
@@ -1760,18 +1632,15 @@ setObjectField(Thread* t, uintptr_t* arguments)
   return 1;
 }
 
-void JNICALL
-SetObjectField(Thread* t, jobject o, jfieldID field, jobject v)
+void JNICALL SetObjectField(Thread* t, jobject o, jfieldID field, jobject v)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            field,
-                            reinterpret_cast<uintptr_t>(v) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(o), field, reinterpret_cast<uintptr_t>(v)};
 
   run(t, setObjectField, arguments);
 }
 
-uint64_t
-setBooleanField(Thread* t, uintptr_t* arguments)
+uint64_t setBooleanField(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   GcField* field = getField(t, arguments[1]);
@@ -1785,18 +1654,14 @@ setBooleanField(Thread* t, uintptr_t* arguments)
   return 1;
 }
 
-void JNICALL
-SetBooleanField(Thread* t, jobject o, jfieldID field, jboolean v)
+void JNICALL SetBooleanField(Thread* t, jobject o, jfieldID field, jboolean v)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            field,
-                            v };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o), field, v};
 
   run(t, setBooleanField, arguments);
 }
 
-uint64_t
-setByteField(Thread* t, uintptr_t* arguments)
+uint64_t setByteField(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   GcField* field = getField(t, arguments[1]);
@@ -1810,18 +1675,15 @@ setByteField(Thread* t, uintptr_t* arguments)
   return 1;
 }
 
-void JNICALL
-SetByteField(Thread* t, jobject o, jfieldID field, jbyte v)
+void JNICALL SetByteField(Thread* t, jobject o, jfieldID field, jbyte v)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            field,
-                            static_cast<uintptr_t>(v) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(o), field, static_cast<uintptr_t>(v)};
 
   run(t, setByteField, arguments);
 }
 
-uint64_t
-setCharField(Thread* t, uintptr_t* arguments)
+uint64_t setCharField(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   GcField* field = getField(t, arguments[1]);
@@ -1835,18 +1697,14 @@ setCharField(Thread* t, uintptr_t* arguments)
   return 1;
 }
 
-void JNICALL
-SetCharField(Thread* t, jobject o, jfieldID field, jchar v)
+void JNICALL SetCharField(Thread* t, jobject o, jfieldID field, jchar v)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            field,
-                            v };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(o), field, v};
 
   run(t, setCharField, arguments);
 }
 
-uint64_t
-setShortField(Thread* t, uintptr_t* arguments)
+uint64_t setShortField(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   GcField* field = getField(t, arguments[1]);
@@ -1860,18 +1718,15 @@ setShortField(Thread* t, uintptr_t* arguments)
   return 1;
 }
 
-void JNICALL
-SetShortField(Thread* t, jobject o, jfieldID field, jshort v)
+void JNICALL SetShortField(Thread* t, jobject o, jfieldID field, jshort v)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            field,
-                            static_cast<uintptr_t>(v) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(o), field, static_cast<uintptr_t>(v)};
 
   run(t, setShortField, arguments);
 }
 
-uint64_t
-setIntField(Thread* t, uintptr_t* arguments)
+uint64_t setIntField(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   GcField* field = getField(t, arguments[1]);
@@ -1885,22 +1740,20 @@ setIntField(Thread* t, uintptr_t* arguments)
   return 1;
 }
 
-void JNICALL
-SetIntField(Thread* t, jobject o, jfieldID field, jint v)
+void JNICALL SetIntField(Thread* t, jobject o, jfieldID field, jint v)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            field,
-                            static_cast<uintptr_t>(v) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(o), field, static_cast<uintptr_t>(v)};
 
   run(t, setIntField, arguments);
 }
 
-uint64_t
-setLongField(Thread* t, uintptr_t* arguments)
+uint64_t setLongField(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   GcField* field = getField(t, arguments[1]);
-  jlong v; memcpy(&v, arguments + 2, sizeof(jlong));
+  jlong v;
+  memcpy(&v, arguments + 2, sizeof(jlong));
 
   PROTECT(t, field);
   ACQUIRE_FIELD_FOR_WRITE(t, field);
@@ -1910,8 +1763,7 @@ setLongField(Thread* t, uintptr_t* arguments)
   return 1;
 }
 
-void JNICALL
-SetLongField(Thread* t, jobject o, jfieldID field, jlong v)
+void JNICALL SetLongField(Thread* t, jobject o, jfieldID field, jlong v)
 {
   uintptr_t arguments[2 + (sizeof(jlong) / BytesPerWord)];
   arguments[0] = reinterpret_cast<uintptr_t>(o);
@@ -1921,8 +1773,7 @@ SetLongField(Thread* t, jobject o, jfieldID field, jlong v)
   run(t, setLongField, arguments);
 }
 
-uint64_t
-setFloatField(Thread* t, uintptr_t* arguments)
+uint64_t setFloatField(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   GcField* field = getField(t, arguments[1]);
@@ -1936,22 +1787,20 @@ setFloatField(Thread* t, uintptr_t* arguments)
   return 1;
 }
 
-void JNICALL
-SetFloatField(Thread* t, jobject o, jfieldID field, jfloat v)
+void JNICALL SetFloatField(Thread* t, jobject o, jfieldID field, jfloat v)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(o),
-                            field,
-                            floatToBits(v) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(o), field, floatToBits(v)};
 
   run(t, setFloatField, arguments);
 }
 
-uint64_t
-setDoubleField(Thread* t, uintptr_t* arguments)
+uint64_t setDoubleField(Thread* t, uintptr_t* arguments)
 {
   jobject o = reinterpret_cast<jobject>(arguments[0]);
   GcField* field = getField(t, arguments[1]);
-  jdouble v; memcpy(&v, arguments + 2, sizeof(jdouble));
+  jdouble v;
+  memcpy(&v, arguments + 2, sizeof(jdouble));
 
   PROTECT(t, field);
   ACQUIRE_FIELD_FOR_WRITE(t, field);
@@ -1961,8 +1810,7 @@ setDoubleField(Thread* t, uintptr_t* arguments)
   return 1;
 }
 
-void JNICALL
-SetDoubleField(Thread* t, jobject o, jfieldID field, jdouble v)
+void JNICALL SetDoubleField(Thread* t, jobject o, jfieldID field, jdouble v)
 {
   uintptr_t arguments[2 + (sizeof(jdouble) / BytesPerWord)];
   arguments[0] = reinterpret_cast<uintptr_t>(o);
@@ -1983,8 +1831,7 @@ GcField* getStaticField(Thread* t, jfieldID f)
   return field;
 }
 
-uint64_t
-getStaticObjectField(Thread* t, uintptr_t* arguments)
+uint64_t getStaticObjectField(Thread* t, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, *reinterpret_cast<jobject>(arguments[0]));
 
@@ -2001,14 +1848,12 @@ getStaticObjectField(Thread* t, uintptr_t* arguments)
 
 jobject JNICALL GetStaticObjectField(Thread* t, jclass c, jfieldID field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            field };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c), field};
 
   return reinterpret_cast<jobject>(run(t, getStaticObjectField, arguments));
 }
 
-uint64_t
-getStaticBooleanField(Thread* t, uintptr_t* arguments)
+uint64_t getStaticBooleanField(Thread* t, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, *reinterpret_cast<jobject>(arguments[0]));
 
@@ -2024,14 +1869,12 @@ getStaticBooleanField(Thread* t, uintptr_t* arguments)
 
 jboolean JNICALL GetStaticBooleanField(Thread* t, jclass c, jfieldID field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            field };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c), field};
 
   return run(t, getStaticBooleanField, arguments);
 }
 
-uint64_t
-getStaticByteField(Thread* t, uintptr_t* arguments)
+uint64_t getStaticByteField(Thread* t, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, *reinterpret_cast<jobject>(arguments[0]));
 
@@ -2047,14 +1890,12 @@ getStaticByteField(Thread* t, uintptr_t* arguments)
 
 jbyte JNICALL GetStaticByteField(Thread* t, jclass c, jfieldID field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            field };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c), field};
 
   return run(t, getStaticByteField, arguments);
 }
 
-uint64_t
-getStaticCharField(Thread* t, uintptr_t* arguments)
+uint64_t getStaticCharField(Thread* t, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, *reinterpret_cast<jobject>(arguments[0]));
 
@@ -2070,14 +1911,12 @@ getStaticCharField(Thread* t, uintptr_t* arguments)
 
 jchar JNICALL GetStaticCharField(Thread* t, jclass c, jfieldID field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            field };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c), field};
 
   return run(t, getStaticCharField, arguments);
 }
 
-uint64_t
-getStaticShortField(Thread* t, uintptr_t* arguments)
+uint64_t getStaticShortField(Thread* t, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, *reinterpret_cast<jobject>(arguments[0]));
 
@@ -2093,14 +1932,12 @@ getStaticShortField(Thread* t, uintptr_t* arguments)
 
 jshort JNICALL GetStaticShortField(Thread* t, jclass c, jfieldID field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            field };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c), field};
 
   return run(t, getStaticShortField, arguments);
 }
 
-uint64_t
-getStaticIntField(Thread* t, uintptr_t* arguments)
+uint64_t getStaticIntField(Thread* t, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, *reinterpret_cast<jobject>(arguments[0]));
 
@@ -2116,14 +1953,12 @@ getStaticIntField(Thread* t, uintptr_t* arguments)
 
 jint JNICALL GetStaticIntField(Thread* t, jclass c, jfieldID field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            field };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c), field};
 
   return run(t, getStaticIntField, arguments);
 }
 
-uint64_t
-getStaticLongField(Thread* t, uintptr_t* arguments)
+uint64_t getStaticLongField(Thread* t, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, *reinterpret_cast<jobject>(arguments[0]));
 
@@ -2139,14 +1974,12 @@ getStaticLongField(Thread* t, uintptr_t* arguments)
 
 jlong JNICALL GetStaticLongField(Thread* t, jclass c, jfieldID field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            field };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c), field};
 
   return run(t, getStaticLongField, arguments);
 }
 
-uint64_t
-getStaticFloatField(Thread* t, uintptr_t* arguments)
+uint64_t getStaticFloatField(Thread* t, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, *reinterpret_cast<jobject>(arguments[0]));
 
@@ -2163,14 +1996,12 @@ getStaticFloatField(Thread* t, uintptr_t* arguments)
 
 jfloat JNICALL GetStaticFloatField(Thread* t, jclass c, jfieldID field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            field };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c), field};
 
   return bitsToFloat(run(t, getStaticFloatField, arguments));
 }
 
-uint64_t
-getStaticDoubleField(Thread* t, uintptr_t* arguments)
+uint64_t getStaticDoubleField(Thread* t, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, *reinterpret_cast<jobject>(arguments[0]));
 
@@ -2187,14 +2018,12 @@ getStaticDoubleField(Thread* t, uintptr_t* arguments)
 
 jdouble JNICALL GetStaticDoubleField(Thread* t, jclass c, jfieldID field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            field };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c), field};
 
   return bitsToDouble(run(t, getStaticDoubleField, arguments));
 }
 
-uint64_t
-setStaticObjectField(Thread* t, uintptr_t* arguments)
+uint64_t setStaticObjectField(Thread* t, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, *reinterpret_cast<jobject>(arguments[0]));
 
@@ -2214,15 +2043,13 @@ setStaticObjectField(Thread* t, uintptr_t* arguments)
 void JNICALL
     SetStaticObjectField(Thread* t, jclass c, jfieldID field, jobject v)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            field,
-                            reinterpret_cast<uintptr_t>(v) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(c), field, reinterpret_cast<uintptr_t>(v)};
 
   run(t, setStaticObjectField, arguments);
 }
 
-uint64_t
-setStaticBooleanField(Thread* t, uintptr_t* arguments)
+uint64_t setStaticBooleanField(Thread* t, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, *reinterpret_cast<jobject>(arguments[0]));
 
@@ -2242,15 +2069,12 @@ setStaticBooleanField(Thread* t, uintptr_t* arguments)
 void JNICALL
     SetStaticBooleanField(Thread* t, jclass c, jfieldID field, jboolean v)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            field,
-                            v };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c), field, v};
 
   run(t, setStaticBooleanField, arguments);
 }
 
-uint64_t
-setStaticByteField(Thread* t, uintptr_t* arguments)
+uint64_t setStaticByteField(Thread* t, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, *reinterpret_cast<jobject>(arguments[0]));
 
@@ -2269,15 +2093,13 @@ setStaticByteField(Thread* t, uintptr_t* arguments)
 
 void JNICALL SetStaticByteField(Thread* t, jclass c, jfieldID field, jbyte v)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            field,
-                            static_cast<uintptr_t>(v) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(c), field, static_cast<uintptr_t>(v)};
 
   run(t, setStaticByteField, arguments);
 }
 
-uint64_t
-setStaticCharField(Thread* t, uintptr_t* arguments)
+uint64_t setStaticCharField(Thread* t, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, *reinterpret_cast<jobject>(arguments[0]));
 
@@ -2296,15 +2118,12 @@ setStaticCharField(Thread* t, uintptr_t* arguments)
 
 void JNICALL SetStaticCharField(Thread* t, jclass c, jfieldID field, jchar v)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            field,
-                            v };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c), field, v};
 
   run(t, setStaticCharField, arguments);
 }
 
-uint64_t
-setStaticShortField(Thread* t, uintptr_t* arguments)
+uint64_t setStaticShortField(Thread* t, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, *reinterpret_cast<jobject>(arguments[0]));
 
@@ -2323,15 +2142,13 @@ setStaticShortField(Thread* t, uintptr_t* arguments)
 
 void JNICALL SetStaticShortField(Thread* t, jclass c, jfieldID field, jshort v)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            field,
-                            static_cast<uintptr_t>(v) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(c), field, static_cast<uintptr_t>(v)};
 
   run(t, setStaticShortField, arguments);
 }
 
-uint64_t
-setStaticIntField(Thread* t, uintptr_t* arguments)
+uint64_t setStaticIntField(Thread* t, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, *reinterpret_cast<jobject>(arguments[0]));
 
@@ -2350,22 +2167,21 @@ setStaticIntField(Thread* t, uintptr_t* arguments)
 
 void JNICALL SetStaticIntField(Thread* t, jclass c, jfieldID field, jint v)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            field,
-                            static_cast<uintptr_t>(v) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(c), field, static_cast<uintptr_t>(v)};
 
   run(t, setStaticIntField, arguments);
 }
 
-uint64_t
-setStaticLongField(Thread* t, uintptr_t* arguments)
+uint64_t setStaticLongField(Thread* t, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, *reinterpret_cast<jobject>(arguments[0]));
 
   initClass(t, c->vmClass());
 
   GcField* field = getStaticField(t, arguments[1]);
-  jlong v; memcpy(&v, arguments + 2, sizeof(jlong));
+  jlong v;
+  memcpy(&v, arguments + 2, sizeof(jlong));
 
   PROTECT(t, field);
   ACQUIRE_FIELD_FOR_WRITE(t, field);
@@ -2385,8 +2201,7 @@ void JNICALL SetStaticLongField(Thread* t, jclass c, jfieldID field, jlong v)
   run(t, setStaticLongField, arguments);
 }
 
-uint64_t
-setStaticFloatField(Thread* t, uintptr_t* arguments)
+uint64_t setStaticFloatField(Thread* t, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, *reinterpret_cast<jobject>(arguments[0]));
 
@@ -2405,22 +2220,21 @@ setStaticFloatField(Thread* t, uintptr_t* arguments)
 
 void JNICALL SetStaticFloatField(Thread* t, jclass c, jfieldID field, jfloat v)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            field,
-                            floatToBits(v) };
+  uintptr_t arguments[]
+      = {reinterpret_cast<uintptr_t>(c), field, floatToBits(v)};
 
   run(t, setStaticFloatField, arguments);
 }
 
-uint64_t
-setStaticDoubleField(Thread* t, uintptr_t* arguments)
+uint64_t setStaticDoubleField(Thread* t, uintptr_t* arguments)
 {
   GcJclass* c = cast<GcJclass>(t, *reinterpret_cast<jobject>(arguments[0]));
 
   initClass(t, c->vmClass());
 
   GcField* field = getStaticField(t, arguments[1]);
-  jdouble v; memcpy(&v, arguments + 2, sizeof(jdouble));
+  jdouble v;
+  memcpy(&v, arguments + 2, sizeof(jdouble));
 
   PROTECT(t, field);
   ACQUIRE_FIELD_FOR_WRITE(t, field);
@@ -2441,8 +2255,7 @@ void JNICALL
   run(t, setStaticDoubleField, arguments);
 }
 
-jobject JNICALL
-newGlobalRef(Thread* t, jobject o, bool weak)
+jobject JNICALL newGlobalRef(Thread* t, jobject o, bool weak)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2458,7 +2271,7 @@ newGlobalRef(Thread* t, jobject o, bool weak)
     }
 
     Reference* r = new (t->m->heap->allocate(sizeof(Reference)))
-      Reference(*o, &(t->m->jniReferences), weak);
+        Reference(*o, &(t->m->jniReferences), weak);
 
     acquire(t, r);
 
@@ -2468,14 +2281,12 @@ newGlobalRef(Thread* t, jobject o, bool weak)
   }
 }
 
-jobject JNICALL
-NewGlobalRef(Thread* t, jobject o)
+jobject JNICALL NewGlobalRef(Thread* t, jobject o)
 {
   return newGlobalRef(t, o, false);
 }
 
-void JNICALL
-DeleteGlobalRef(Thread* t, jobject r)
+void JNICALL DeleteGlobalRef(Thread* t, jobject r)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2486,50 +2297,43 @@ DeleteGlobalRef(Thread* t, jobject r)
   }
 }
 
-jobject JNICALL
-NewWeakGlobalRef(Thread* t, jobject o)
+jobject JNICALL NewWeakGlobalRef(Thread* t, jobject o)
 {
   return newGlobalRef(t, o, true);
 }
 
-void JNICALL
-DeleteWeakGlobalRef(Thread* t, jobject r)
+void JNICALL DeleteWeakGlobalRef(Thread* t, jobject r)
 {
   DeleteGlobalRef(t, r);
 }
 
-jint JNICALL
-EnsureLocalCapacity(Thread*, jint)
+jint JNICALL EnsureLocalCapacity(Thread*, jint)
 {
   return 0;
 }
 
-jthrowable JNICALL
-ExceptionOccurred(Thread* t)
+jthrowable JNICALL ExceptionOccurred(Thread* t)
 {
   ENTER(t, Thread::ActiveState);
 
   return reinterpret_cast<jthrowable>(makeLocalReference(t, t->exception));
 }
 
-void JNICALL
-ExceptionDescribe(Thread* t)
+void JNICALL ExceptionDescribe(Thread* t)
 {
   ENTER(t, Thread::ActiveState);
 
   return printTrace(t, t->exception);
 }
 
-void JNICALL
-ExceptionClear(Thread* t)
+void JNICALL ExceptionClear(Thread* t)
 {
   ENTER(t, Thread::ActiveState);
 
   t->exception = 0;
 }
 
-uint64_t
-newObjectArray(Thread* t, uintptr_t* arguments)
+uint64_t newObjectArray(Thread* t, uintptr_t* arguments)
 {
   jsize length = arguments[0];
   jclass class_ = reinterpret_cast<jclass>(arguments[1]);
@@ -2544,17 +2348,17 @@ newObjectArray(Thread* t, uintptr_t* arguments)
 }
 
 jobjectArray JNICALL
-NewObjectArray(Thread* t, jsize length, jclass class_, jobject init)
+    NewObjectArray(Thread* t, jsize length, jclass class_, jobject init)
 {
-  uintptr_t arguments[] = { static_cast<uintptr_t>(length),
-                            reinterpret_cast<uintptr_t>(class_),
-                            reinterpret_cast<uintptr_t>(init) };
+  uintptr_t arguments[] = {static_cast<uintptr_t>(length),
+                           reinterpret_cast<uintptr_t>(class_),
+                           reinterpret_cast<uintptr_t>(init)};
 
   return reinterpret_cast<jobjectArray>(run(t, newObjectArray, arguments));
 }
 
 jobject JNICALL
-GetObjectArrayElement(Thread* t, jobjectArray array, jsize index)
+    GetObjectArrayElement(Thread* t, jobjectArray array, jsize index)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2562,9 +2366,10 @@ GetObjectArrayElement(Thread* t, jobjectArray array, jsize index)
       t, objectArrayBody(t, reinterpret_cast<object>(*array), index));
 }
 
-void JNICALL
-SetObjectArrayElement(Thread* t, jobjectArray array, jsize index,
-                      jobject value)
+void JNICALL SetObjectArrayElement(Thread* t,
+                                   jobjectArray array,
+                                   jsize index,
+                                   jobject value)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2574,106 +2379,96 @@ SetObjectArrayElement(Thread* t, jobjectArray array, jsize index,
            (value ? *value : 0));
 }
 
-uint64_t
-newArray(Thread* t, uintptr_t* arguments)
+uint64_t newArray(Thread* t, uintptr_t* arguments)
 {
   object (*constructor)(Thread*, unsigned)
-    = reinterpret_cast<object (*)(Thread*, unsigned)>(arguments[0]);
+      = reinterpret_cast<object (*)(Thread*, unsigned)>(arguments[0]);
 
   jsize length = arguments[1];
 
-  return reinterpret_cast<uint64_t>
-    (makeLocalReference(t, constructor(t, length)));
+  return reinterpret_cast<uint64_t>(
+      makeLocalReference(t, constructor(t, length)));
 }
 
-jbooleanArray JNICALL
-NewBooleanArray(Thread* t, jsize length)
+jbooleanArray JNICALL NewBooleanArray(Thread* t, jsize length)
 {
   uintptr_t arguments[]
-    = { reinterpret_cast<uintptr_t>(voidPointer(makeBooleanArray)),
-        static_cast<uintptr_t>(length) };
+      = {reinterpret_cast<uintptr_t>(voidPointer(makeBooleanArray)),
+         static_cast<uintptr_t>(length)};
 
   return reinterpret_cast<jbooleanArray>(run(t, newArray, arguments));
 }
 
-object
-makeByteArray0(Thread* t, unsigned length)
+object makeByteArray0(Thread* t, unsigned length)
 {
   return makeByteArray(t, length);
 }
 
-jbyteArray JNICALL
-NewByteArray(Thread* t, jsize length)
+jbyteArray JNICALL NewByteArray(Thread* t, jsize length)
 {
   uintptr_t arguments[]
-    = { reinterpret_cast<uintptr_t>(voidPointer(makeByteArray0)),
-        static_cast<uintptr_t>(length) };
+      = {reinterpret_cast<uintptr_t>(voidPointer(makeByteArray0)),
+         static_cast<uintptr_t>(length)};
 
   return reinterpret_cast<jbyteArray>(run(t, newArray, arguments));
 }
 
-jcharArray JNICALL
-NewCharArray(Thread* t, jsize length)
+jcharArray JNICALL NewCharArray(Thread* t, jsize length)
 {
   uintptr_t arguments[]
-    = { reinterpret_cast<uintptr_t>(voidPointer(makeCharArray)),
-        static_cast<uintptr_t>(length) };
+      = {reinterpret_cast<uintptr_t>(voidPointer(makeCharArray)),
+         static_cast<uintptr_t>(length)};
 
   return reinterpret_cast<jcharArray>(run(t, newArray, arguments));
 }
 
-jshortArray JNICALL
-NewShortArray(Thread* t, jsize length)
+jshortArray JNICALL NewShortArray(Thread* t, jsize length)
 {
   uintptr_t arguments[]
-    = { reinterpret_cast<uintptr_t>(voidPointer(makeShortArray)),
-        static_cast<uintptr_t>(length) };
+      = {reinterpret_cast<uintptr_t>(voidPointer(makeShortArray)),
+         static_cast<uintptr_t>(length)};
 
   return reinterpret_cast<jshortArray>(run(t, newArray, arguments));
 }
 
-jintArray JNICALL
-NewIntArray(Thread* t, jsize length)
+jintArray JNICALL NewIntArray(Thread* t, jsize length)
 {
   uintptr_t arguments[]
-    = { reinterpret_cast<uintptr_t>(voidPointer(makeIntArray)),
-        static_cast<uintptr_t>(length) };
+      = {reinterpret_cast<uintptr_t>(voidPointer(makeIntArray)),
+         static_cast<uintptr_t>(length)};
 
   return reinterpret_cast<jintArray>(run(t, newArray, arguments));
 }
 
-jlongArray JNICALL
-NewLongArray(Thread* t, jsize length)
+jlongArray JNICALL NewLongArray(Thread* t, jsize length)
 {
   uintptr_t arguments[]
-    = { reinterpret_cast<uintptr_t>(voidPointer(makeLongArray)),
-        static_cast<uintptr_t>(length) };
+      = {reinterpret_cast<uintptr_t>(voidPointer(makeLongArray)),
+         static_cast<uintptr_t>(length)};
 
   return reinterpret_cast<jlongArray>(run(t, newArray, arguments));
 }
 
-jfloatArray JNICALL
-NewFloatArray(Thread* t, jsize length)
+jfloatArray JNICALL NewFloatArray(Thread* t, jsize length)
 {
   uintptr_t arguments[]
-    = { reinterpret_cast<uintptr_t>(voidPointer(makeFloatArray)),
-        static_cast<uintptr_t>(length) };
+      = {reinterpret_cast<uintptr_t>(voidPointer(makeFloatArray)),
+         static_cast<uintptr_t>(length)};
 
   return reinterpret_cast<jfloatArray>(run(t, newArray, arguments));
 }
 
-jdoubleArray JNICALL
-NewDoubleArray(Thread* t, jsize length)
+jdoubleArray JNICALL NewDoubleArray(Thread* t, jsize length)
 {
   uintptr_t arguments[]
-    = { reinterpret_cast<uintptr_t>(voidPointer(makeDoubleArray)),
-        static_cast<uintptr_t>(length) };
+      = {reinterpret_cast<uintptr_t>(voidPointer(makeDoubleArray)),
+         static_cast<uintptr_t>(length)};
 
   return reinterpret_cast<jdoubleArray>(run(t, newArray, arguments));
 }
 
 jboolean* JNICALL
-GetBooleanArrayElements(Thread* t, jbooleanArray array, jboolean* isCopy)
+    GetBooleanArrayElements(Thread* t, jbooleanArray array, jboolean* isCopy)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2691,7 +2486,7 @@ GetBooleanArrayElements(Thread* t, jbooleanArray array, jboolean* isCopy)
 }
 
 jbyte* JNICALL
-GetByteArrayElements(Thread* t, jbyteArray array, jboolean* isCopy)
+    GetByteArrayElements(Thread* t, jbyteArray array, jboolean* isCopy)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2709,7 +2504,7 @@ GetByteArrayElements(Thread* t, jbyteArray array, jboolean* isCopy)
 }
 
 jchar* JNICALL
-GetCharArrayElements(Thread* t, jcharArray array, jboolean* isCopy)
+    GetCharArrayElements(Thread* t, jcharArray array, jboolean* isCopy)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2727,7 +2522,7 @@ GetCharArrayElements(Thread* t, jcharArray array, jboolean* isCopy)
 }
 
 jshort* JNICALL
-GetShortArrayElements(Thread* t, jshortArray array, jboolean* isCopy)
+    GetShortArrayElements(Thread* t, jshortArray array, jboolean* isCopy)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2744,8 +2539,7 @@ GetShortArrayElements(Thread* t, jshortArray array, jboolean* isCopy)
   return p;
 }
 
-jint* JNICALL
-GetIntArrayElements(Thread* t, jintArray array, jboolean* isCopy)
+jint* JNICALL GetIntArrayElements(Thread* t, jintArray array, jboolean* isCopy)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2763,7 +2557,7 @@ GetIntArrayElements(Thread* t, jintArray array, jboolean* isCopy)
 }
 
 jlong* JNICALL
-GetLongArrayElements(Thread* t, jlongArray array, jboolean* isCopy)
+    GetLongArrayElements(Thread* t, jlongArray array, jboolean* isCopy)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2781,7 +2575,7 @@ GetLongArrayElements(Thread* t, jlongArray array, jboolean* isCopy)
 }
 
 jfloat* JNICALL
-GetFloatArrayElements(Thread* t, jfloatArray array, jboolean* isCopy)
+    GetFloatArrayElements(Thread* t, jfloatArray array, jboolean* isCopy)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2799,7 +2593,7 @@ GetFloatArrayElements(Thread* t, jfloatArray array, jboolean* isCopy)
 }
 
 jdouble* JNICALL
-GetDoubleArrayElements(Thread* t, jdoubleArray array, jboolean* isCopy)
+    GetDoubleArrayElements(Thread* t, jdoubleArray array, jboolean* isCopy)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2816,9 +2610,10 @@ GetDoubleArrayElements(Thread* t, jdoubleArray array, jboolean* isCopy)
   return p;
 }
 
-void JNICALL
-ReleaseBooleanArrayElements(Thread* t, jbooleanArray array, jboolean* p,
-                            jint mode)
+void JNICALL ReleaseBooleanArrayElements(Thread* t,
+                                         jbooleanArray array,
+                                         jboolean* p,
+                                         jint mode)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2836,7 +2631,7 @@ ReleaseBooleanArrayElements(Thread* t, jbooleanArray array, jboolean* p,
 }
 
 void JNICALL
-ReleaseByteArrayElements(Thread* t, jbyteArray array, jbyte* p, jint mode)
+    ReleaseByteArrayElements(Thread* t, jbyteArray array, jbyte* p, jint mode)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2854,7 +2649,7 @@ ReleaseByteArrayElements(Thread* t, jbyteArray array, jbyte* p, jint mode)
 }
 
 void JNICALL
-ReleaseCharArrayElements(Thread* t, jcharArray array, jchar* p, jint mode)
+    ReleaseCharArrayElements(Thread* t, jcharArray array, jchar* p, jint mode)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2871,8 +2666,10 @@ ReleaseCharArrayElements(Thread* t, jcharArray array, jchar* p, jint mode)
   }
 }
 
-void JNICALL
-ReleaseShortArrayElements(Thread* t, jshortArray array, jshort* p, jint mode)
+void JNICALL ReleaseShortArrayElements(Thread* t,
+                                       jshortArray array,
+                                       jshort* p,
+                                       jint mode)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2890,7 +2687,7 @@ ReleaseShortArrayElements(Thread* t, jshortArray array, jshort* p, jint mode)
 }
 
 void JNICALL
-ReleaseIntArrayElements(Thread* t, jintArray array, jint* p, jint mode)
+    ReleaseIntArrayElements(Thread* t, jintArray array, jint* p, jint mode)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2908,7 +2705,7 @@ ReleaseIntArrayElements(Thread* t, jintArray array, jint* p, jint mode)
 }
 
 void JNICALL
-ReleaseLongArrayElements(Thread* t, jlongArray array, jlong* p, jint mode)
+    ReleaseLongArrayElements(Thread* t, jlongArray array, jlong* p, jint mode)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2925,8 +2722,10 @@ ReleaseLongArrayElements(Thread* t, jlongArray array, jlong* p, jint mode)
   }
 }
 
-void JNICALL
-ReleaseFloatArrayElements(Thread* t, jfloatArray array, jfloat* p, jint mode)
+void JNICALL ReleaseFloatArrayElements(Thread* t,
+                                       jfloatArray array,
+                                       jfloat* p,
+                                       jint mode)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2943,9 +2742,10 @@ ReleaseFloatArrayElements(Thread* t, jfloatArray array, jfloat* p, jint mode)
   }
 }
 
-void JNICALL
-ReleaseDoubleArrayElements(Thread* t, jdoubleArray array, jdouble* p,
-                           jint mode)
+void JNICALL ReleaseDoubleArrayElements(Thread* t,
+                                        jdoubleArray array,
+                                        jdouble* p,
+                                        jint mode)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2962,9 +2762,11 @@ ReleaseDoubleArrayElements(Thread* t, jdoubleArray array, jdouble* p,
   }
 }
 
-void JNICALL
-GetBooleanArrayRegion(Thread* t, jbooleanArray array, jint offset, jint length,
-                      jboolean* dst)
+void JNICALL GetBooleanArrayRegion(Thread* t,
+                                   jbooleanArray array,
+                                   jint offset,
+                                   jint length,
+                                   jboolean* dst)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2973,9 +2775,11 @@ GetBooleanArrayRegion(Thread* t, jbooleanArray array, jint offset, jint length,
   }
 }
 
-void JNICALL
-GetByteArrayRegion(Thread* t, jbyteArray array, jint offset, jint length,
-                   jbyte* dst)
+void JNICALL GetByteArrayRegion(Thread* t,
+                                jbyteArray array,
+                                jint offset,
+                                jint length,
+                                jbyte* dst)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2984,9 +2788,11 @@ GetByteArrayRegion(Thread* t, jbyteArray array, jint offset, jint length,
   }
 }
 
-void JNICALL
-GetCharArrayRegion(Thread* t, jcharArray array, jint offset, jint length,
-                   jchar* dst)
+void JNICALL GetCharArrayRegion(Thread* t,
+                                jcharArray array,
+                                jint offset,
+                                jint length,
+                                jchar* dst)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -2995,9 +2801,11 @@ GetCharArrayRegion(Thread* t, jcharArray array, jint offset, jint length,
   }
 }
 
-void JNICALL
-GetShortArrayRegion(Thread* t, jshortArray array, jint offset, jint length,
-                    jshort* dst)
+void JNICALL GetShortArrayRegion(Thread* t,
+                                 jshortArray array,
+                                 jint offset,
+                                 jint length,
+                                 jshort* dst)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3006,9 +2814,11 @@ GetShortArrayRegion(Thread* t, jshortArray array, jint offset, jint length,
   }
 }
 
-void JNICALL
-GetIntArrayRegion(Thread* t, jintArray array, jint offset, jint length,
-                  jint* dst)
+void JNICALL GetIntArrayRegion(Thread* t,
+                               jintArray array,
+                               jint offset,
+                               jint length,
+                               jint* dst)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3017,9 +2827,11 @@ GetIntArrayRegion(Thread* t, jintArray array, jint offset, jint length,
   }
 }
 
-void JNICALL
-GetLongArrayRegion(Thread* t, jlongArray array, jint offset, jint length,
-                   jlong* dst)
+void JNICALL GetLongArrayRegion(Thread* t,
+                                jlongArray array,
+                                jint offset,
+                                jint length,
+                                jlong* dst)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3028,9 +2840,11 @@ GetLongArrayRegion(Thread* t, jlongArray array, jint offset, jint length,
   }
 }
 
-void JNICALL
-GetFloatArrayRegion(Thread* t, jfloatArray array, jint offset, jint length,
-                    jfloat* dst)
+void JNICALL GetFloatArrayRegion(Thread* t,
+                                 jfloatArray array,
+                                 jint offset,
+                                 jint length,
+                                 jfloat* dst)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3039,9 +2853,11 @@ GetFloatArrayRegion(Thread* t, jfloatArray array, jint offset, jint length,
   }
 }
 
-void JNICALL
-GetDoubleArrayRegion(Thread* t, jdoubleArray array, jint offset, jint length,
-                     jdouble* dst)
+void JNICALL GetDoubleArrayRegion(Thread* t,
+                                  jdoubleArray array,
+                                  jint offset,
+                                  jint length,
+                                  jdouble* dst)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3050,9 +2866,11 @@ GetDoubleArrayRegion(Thread* t, jdoubleArray array, jint offset, jint length,
   }
 }
 
-void JNICALL
-SetBooleanArrayRegion(Thread* t, jbooleanArray array, jint offset, jint length,
-                      const jboolean* src)
+void JNICALL SetBooleanArrayRegion(Thread* t,
+                                   jbooleanArray array,
+                                   jint offset,
+                                   jint length,
+                                   const jboolean* src)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3061,9 +2879,11 @@ SetBooleanArrayRegion(Thread* t, jbooleanArray array, jint offset, jint length,
   }
 }
 
-void JNICALL
-SetByteArrayRegion(Thread* t, jbyteArray array, jint offset, jint length,
-                   const jbyte* src)
+void JNICALL SetByteArrayRegion(Thread* t,
+                                jbyteArray array,
+                                jint offset,
+                                jint length,
+                                const jbyte* src)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3072,9 +2892,11 @@ SetByteArrayRegion(Thread* t, jbyteArray array, jint offset, jint length,
   }
 }
 
-void JNICALL
-SetCharArrayRegion(Thread* t, jcharArray array, jint offset, jint length,
-                   const jchar* src)
+void JNICALL SetCharArrayRegion(Thread* t,
+                                jcharArray array,
+                                jint offset,
+                                jint length,
+                                const jchar* src)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3083,9 +2905,11 @@ SetCharArrayRegion(Thread* t, jcharArray array, jint offset, jint length,
   }
 }
 
-void JNICALL
-SetShortArrayRegion(Thread* t, jshortArray array, jint offset, jint length,
-                    const jshort* src)
+void JNICALL SetShortArrayRegion(Thread* t,
+                                 jshortArray array,
+                                 jint offset,
+                                 jint length,
+                                 const jshort* src)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3094,9 +2918,11 @@ SetShortArrayRegion(Thread* t, jshortArray array, jint offset, jint length,
   }
 }
 
-void JNICALL
-SetIntArrayRegion(Thread* t, jintArray array, jint offset, jint length,
-                  const jint* src)
+void JNICALL SetIntArrayRegion(Thread* t,
+                               jintArray array,
+                               jint offset,
+                               jint length,
+                               const jint* src)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3105,9 +2931,11 @@ SetIntArrayRegion(Thread* t, jintArray array, jint offset, jint length,
   }
 }
 
-void JNICALL
-SetLongArrayRegion(Thread* t, jlongArray array, jint offset, jint length,
-                   const jlong* src)
+void JNICALL SetLongArrayRegion(Thread* t,
+                                jlongArray array,
+                                jint offset,
+                                jint length,
+                                const jlong* src)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3116,9 +2944,11 @@ SetLongArrayRegion(Thread* t, jlongArray array, jint offset, jint length,
   }
 }
 
-void JNICALL
-SetFloatArrayRegion(Thread* t, jfloatArray array, jint offset, jint length,
-                    const jfloat* src)
+void JNICALL SetFloatArrayRegion(Thread* t,
+                                 jfloatArray array,
+                                 jint offset,
+                                 jint length,
+                                 const jfloat* src)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3127,9 +2957,11 @@ SetFloatArrayRegion(Thread* t, jfloatArray array, jint offset, jint length,
   }
 }
 
-void JNICALL
-SetDoubleArrayRegion(Thread* t, jdoubleArray array, jint offset, jint length,
-                     const jdouble* src)
+void JNICALL SetDoubleArrayRegion(Thread* t,
+                                  jdoubleArray array,
+                                  jint offset,
+                                  jint length,
+                                  const jdouble* src)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3139,13 +2971,13 @@ SetDoubleArrayRegion(Thread* t, jdoubleArray array, jint offset, jint length,
 }
 
 void* JNICALL
-GetPrimitiveArrayCritical(Thread* t, jarray array, jboolean* isCopy)
+    GetPrimitiveArrayCritical(Thread* t, jarray array, jboolean* isCopy)
 {
   if (t->criticalLevel == 0) {
     enter(t, Thread::ActiveState);
   }
 
-  ++ t->criticalLevel;
+  ++t->criticalLevel;
 
   if (isCopy) {
     *isCopy = true;
@@ -3156,96 +2988,88 @@ GetPrimitiveArrayCritical(Thread* t, jarray array, jboolean* isCopy)
   return reinterpret_cast<uintptr_t*>(*array) + 2;
 }
 
-void JNICALL
-ReleasePrimitiveArrayCritical(Thread* t, jarray, void*, jint)
+void JNICALL ReleasePrimitiveArrayCritical(Thread* t, jarray, void*, jint)
 {
-  if ((-- t->criticalLevel) == 0) {
+  if ((--t->criticalLevel) == 0) {
     enter(t, Thread::IdleState);
   }
 }
 
-uint64_t
-fromReflectedMethod(Thread* t, uintptr_t* arguments)
+uint64_t fromReflectedMethod(Thread* t, uintptr_t* arguments)
 {
   jobject m = reinterpret_cast<jobject>(arguments[0]);
 
   return methodID(t, t->m->classpath->getVMMethod(t, *m));
 }
 
-jmethodID JNICALL
-FromReflectedMethod(Thread* t, jobject method)
+jmethodID JNICALL FromReflectedMethod(Thread* t, jobject method)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(method) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(method)};
 
   return static_cast<jmethodID>(run(t, fromReflectedMethod, arguments));
 }
 
-uint64_t
-toReflectedMethod(Thread* t, uintptr_t* arguments)
+uint64_t toReflectedMethod(Thread* t, uintptr_t* arguments)
 {
   jmethodID m = arguments[1];
   jboolean isStatic = arguments[2];
 
-  return reinterpret_cast<uintptr_t>
-    (makeLocalReference
-     (t, t->m->classpath->makeJMethod
-      (t, isStatic ? getStaticMethod(t, m) : getMethod(t, m))));
+  return reinterpret_cast<uintptr_t>(makeLocalReference(
+      t,
+      t->m->classpath->makeJMethod(
+          t, isStatic ? getStaticMethod(t, m) : getMethod(t, m))));
 }
 
 jobject JNICALL
-ToReflectedMethod(Thread* t, jclass c, jmethodID method, jboolean isStatic)
+    ToReflectedMethod(Thread* t, jclass c, jmethodID method, jboolean isStatic)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            static_cast<uintptr_t>(method),
-                            static_cast<uintptr_t>(isStatic) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c),
+                           static_cast<uintptr_t>(method),
+                           static_cast<uintptr_t>(isStatic)};
 
   return reinterpret_cast<jobject>(run(t, toReflectedMethod, arguments));
 }
 
-uint64_t
-fromReflectedField(Thread* t, uintptr_t* arguments)
+uint64_t fromReflectedField(Thread* t, uintptr_t* arguments)
 {
   jobject f = reinterpret_cast<jobject>(arguments[0]);
 
   return fieldID(t, t->m->classpath->getVMField(t, cast<GcJfield>(t, *f)));
 }
 
-jfieldID JNICALL
-FromReflectedField(Thread* t, jobject field)
+jfieldID JNICALL FromReflectedField(Thread* t, jobject field)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(field) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(field)};
 
   return static_cast<jfieldID>(run(t, fromReflectedField, arguments));
 }
 
-uint64_t
-toReflectedField(Thread* t, uintptr_t* arguments)
+uint64_t toReflectedField(Thread* t, uintptr_t* arguments)
 {
   jfieldID f = arguments[1];
   jboolean isStatic = arguments[2];
 
-  return reinterpret_cast<uintptr_t>
-    (makeLocalReference
-     (t, t->m->classpath->makeJField
-      (t, isStatic ? getStaticField(t, f) : getField(t, f))));
+  return reinterpret_cast<uintptr_t>(makeLocalReference(
+      t,
+      t->m->classpath->makeJField(
+          t, isStatic ? getStaticField(t, f) : getField(t, f))));
 }
 
 jobject JNICALL
-ToReflectedField(Thread* t, jclass c, jfieldID field, jboolean isStatic)
+    ToReflectedField(Thread* t, jclass c, jfieldID field, jboolean isStatic)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            static_cast<uintptr_t>(field),
-                            static_cast<uintptr_t>(isStatic) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c),
+                           static_cast<uintptr_t>(field),
+                           static_cast<uintptr_t>(isStatic)};
 
   return reinterpret_cast<jobject>(run(t, toReflectedField, arguments));
 }
 
-uint64_t
-registerNatives(Thread* t, uintptr_t* arguments)
+uint64_t registerNatives(Thread* t, uintptr_t* arguments)
 {
   jclass c = reinterpret_cast<jclass>(arguments[0]);
   const JNINativeMethod* methods
-    = reinterpret_cast<const JNINativeMethod*>(arguments[1]);
+      = reinterpret_cast<const JNINativeMethod*>(arguments[1]);
   jint methodCount = arguments[2];
 
   for (int i = 0; i < methodCount; ++i) {
@@ -3253,7 +3077,8 @@ registerNatives(Thread* t, uintptr_t* arguments)
       // Android's class library sometimes prepends a mysterious "!"
       // to the method signature, which we happily ignore:
       const char* sig = methods[i].signature;
-      if (*sig == '!') ++ sig;
+      if (*sig == '!')
+        ++sig;
 
       GcMethod* method
           = findMethodOrNull(t, (*c)->vmClass(), methods[i].name, sig);
@@ -3275,19 +3100,19 @@ registerNatives(Thread* t, uintptr_t* arguments)
   return 1;
 }
 
-jint JNICALL
-RegisterNatives(Thread* t, jclass c, const JNINativeMethod* methods,
-                jint methodCount)
+jint JNICALL RegisterNatives(Thread* t,
+                             jclass c,
+                             const JNINativeMethod* methods,
+                             jint methodCount)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(c),
-                            reinterpret_cast<uintptr_t>(methods),
-                            static_cast<uintptr_t>(methodCount) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(c),
+                           reinterpret_cast<uintptr_t>(methods),
+                           static_cast<uintptr_t>(methodCount)};
 
   return run(t, registerNatives, arguments) ? 0 : -1;
 }
 
-jint JNICALL
-UnregisterNatives(Thread* t, jclass c)
+jint JNICALL UnregisterNatives(Thread* t, jclass c)
 {
   ENTER(t, Thread::ActiveState);
 
@@ -3296,11 +3121,10 @@ UnregisterNatives(Thread* t, jclass c)
   return 0;
 }
 
-uint64_t
-monitorOp(Thread* t, uintptr_t* arguments)
+uint64_t monitorOp(Thread* t, uintptr_t* arguments)
 {
   void (*op)(Thread*, object)
-    = reinterpret_cast<void (*)(Thread*, object)>(arguments[0]);
+      = reinterpret_cast<void (*)(Thread*, object)>(arguments[0]);
 
   jobject o = reinterpret_cast<jobject>(arguments[1]);
 
@@ -3309,47 +3133,39 @@ monitorOp(Thread* t, uintptr_t* arguments)
   return 1;
 }
 
-void
-acquire0(Thread* t, object o)
+void acquire0(Thread* t, object o)
 {
   return acquire(t, o);
 }
 
-jint JNICALL
-MonitorEnter(Thread* t, jobject o)
+jint JNICALL MonitorEnter(Thread* t, jobject o)
 {
-  uintptr_t arguments[]
-    = { reinterpret_cast<uintptr_t>(voidPointer(acquire0)),
-        reinterpret_cast<uintptr_t>(o) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(voidPointer(acquire0)),
+                           reinterpret_cast<uintptr_t>(o)};
 
   return run(t, monitorOp, arguments) ? 0 : -1;
 }
 
-void
-release0(Thread* t, object o)
+void release0(Thread* t, object o)
 {
   return release(t, o);
 }
 
-jint JNICALL
-MonitorExit(Thread* t, jobject o)
+jint JNICALL MonitorExit(Thread* t, jobject o)
 {
-  uintptr_t arguments[]
-    = { reinterpret_cast<uintptr_t>(voidPointer(release0)),
-        reinterpret_cast<uintptr_t>(o) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(voidPointer(release0)),
+                           reinterpret_cast<uintptr_t>(o)};
 
   return run(t, monitorOp, arguments) ? 0 : -1;
 }
 
-jint JNICALL
-GetJavaVM(Thread* t, Machine** m)
+jint JNICALL GetJavaVM(Thread* t, Machine** m)
 {
   *m = t->m;
   return 0;
 }
 
-jboolean JNICALL
-IsSameObject(Thread* t, jobject a, jobject b)
+jboolean JNICALL IsSameObject(Thread* t, jobject a, jobject b)
 {
   if (a and b) {
     ENTER(t, Thread::ActiveState);
@@ -3360,8 +3176,7 @@ IsSameObject(Thread* t, jobject a, jobject b)
   }
 }
 
-uint64_t
-pushLocalFrame(Thread* t, uintptr_t* arguments)
+uint64_t pushLocalFrame(Thread* t, uintptr_t* arguments)
 {
   if (t->m->processor->pushLocalFrame(t, arguments[0])) {
     return 1;
@@ -3370,20 +3185,18 @@ pushLocalFrame(Thread* t, uintptr_t* arguments)
   }
 }
 
-jint JNICALL
-PushLocalFrame(Thread* t, jint capacity)
+jint JNICALL PushLocalFrame(Thread* t, jint capacity)
 {
-  uintptr_t arguments[] = { static_cast<uintptr_t>(capacity) };
+  uintptr_t arguments[] = {static_cast<uintptr_t>(capacity)};
 
   return run(t, pushLocalFrame, arguments) ? 0 : -1;
 }
 
-uint64_t
-popLocalFrame(Thread* t, uintptr_t* arguments)
+uint64_t popLocalFrame(Thread* t, uintptr_t* arguments)
 {
   uint64_t r;
   jobject presult = reinterpret_cast<jobject>(arguments[0]);
-  if(presult != NULL) {
+  if (presult != NULL) {
     object result = *presult;
     PROTECT(t, result);
 
@@ -3398,27 +3211,25 @@ popLocalFrame(Thread* t, uintptr_t* arguments)
   return r;
 }
 
-jobject JNICALL
-PopLocalFrame(Thread* t, jobject result)
+jobject JNICALL PopLocalFrame(Thread* t, jobject result)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(result) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(result)};
 
   return reinterpret_cast<jobject>(run(t, popLocalFrame, arguments));
 }
 
-uint64_t
-newDirectByteBuffer(Thread* t, uintptr_t* arguments)
+uint64_t newDirectByteBuffer(Thread* t, uintptr_t* arguments)
 {
-  jlong capacity; memcpy(&capacity, arguments + 1, sizeof(jlong));
+  jlong capacity;
+  memcpy(&capacity, arguments + 1, sizeof(jlong));
 
-  return reinterpret_cast<uintptr_t>
-    (makeLocalReference
-     (t, t->m->classpath->makeDirectByteBuffer
-      (t, reinterpret_cast<void*>(arguments[0]), capacity)));
+  return reinterpret_cast<uintptr_t>(makeLocalReference(
+      t,
+      t->m->classpath->makeDirectByteBuffer(
+          t, reinterpret_cast<void*>(arguments[0]), capacity)));
 }
 
-jobject JNICALL
-NewDirectByteBuffer(Thread* t, void* p, jlong capacity)
+jobject JNICALL NewDirectByteBuffer(Thread* t, void* p, jlong capacity)
 {
   uintptr_t arguments[1 + (sizeof(jlong) / BytesPerWord)];
   arguments[0] = reinterpret_cast<uintptr_t>(p);
@@ -3427,33 +3238,28 @@ NewDirectByteBuffer(Thread* t, void* p, jlong capacity)
   return reinterpret_cast<jobject>(run(t, newDirectByteBuffer, arguments));
 }
 
-uint64_t
-getDirectBufferAddress(Thread* t, uintptr_t* arguments)
+uint64_t getDirectBufferAddress(Thread* t, uintptr_t* arguments)
 {
-  return reinterpret_cast<uintptr_t>
-    (t->m->classpath->getDirectBufferAddress
-     (t, *reinterpret_cast<jobject>(arguments[0])));
+  return reinterpret_cast<uintptr_t>(t->m->classpath->getDirectBufferAddress(
+      t, *reinterpret_cast<jobject>(arguments[0])));
 }
 
-void* JNICALL
-GetDirectBufferAddress(Thread* t, jobject b)
+void* JNICALL GetDirectBufferAddress(Thread* t, jobject b)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(b) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(b)};
 
   return reinterpret_cast<void*>(run(t, getDirectBufferAddress, arguments));
 }
 
-uint64_t
-getDirectBufferCapacity(Thread* t, uintptr_t* arguments)
+uint64_t getDirectBufferCapacity(Thread* t, uintptr_t* arguments)
 {
-  return t->m->classpath->getDirectBufferCapacity
-    (t, *reinterpret_cast<jobject>(arguments[0]));
+  return t->m->classpath->getDirectBufferCapacity(
+      t, *reinterpret_cast<jobject>(arguments[0]));
 }
 
-jlong JNICALL
-GetDirectBufferCapacity(Thread* t, jobject b)
+jlong JNICALL GetDirectBufferCapacity(Thread* t, jobject b)
 {
-  uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(b) };
+  uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(b)};
 
   return run(t, getDirectBufferCapacity, arguments);
 }
@@ -3471,8 +3277,7 @@ struct JavaVMInitArgs {
   jboolean ignoreUnrecognized;
 };
 
-int
-parseSize(const char* s)
+int parseSize(const char* s)
 {
   unsigned length = strlen(s);
   RUNTIME_ARRAY(char, buffer, length + 1);
@@ -3491,8 +3296,7 @@ parseSize(const char* s)
   }
 }
 
-void
-append(char** p, const char* value, unsigned length, char tail)
+void append(char** p, const char* value, unsigned length, char tail)
 {
   if (length) {
     memcpy(*p, value, length);
@@ -3501,8 +3305,7 @@ append(char** p, const char* value, unsigned length, char tail)
   }
 }
 
-uint64_t
-boot(Thread* t, uintptr_t*)
+uint64_t boot(Thread* t, uintptr_t*)
 {
   GcThrowable* throwable = makeThrowable(t, GcNullPointerException::Type);
   // sequence point, for gc (don't recombine statements)
@@ -3557,14 +3360,13 @@ boot(Thread* t, uintptr_t*)
   return 1;
 }
 
-} // namespace local
+}  // namespace local
 
-} // namespace
+}  // namespace
 
 namespace vm {
 
-void
-populateJNITables(JavaVMVTable* vmTable, JNIEnvVTable* envTable)
+void populateJNITables(JavaVMVTable* vmTable, JNIEnvVTable* envTable)
 {
   memset(vmTable, 0, sizeof(JavaVMVTable));
 
@@ -3760,7 +3562,7 @@ populateJNITables(JavaVMVTable* vmTable, JNIEnvVTable* envTable)
   envTable->SetDoubleArrayRegion = local::SetDoubleArrayRegion;
   envTable->GetPrimitiveArrayCritical = local::GetPrimitiveArrayCritical;
   envTable->ReleasePrimitiveArrayCritical
-    = local::ReleasePrimitiveArrayCritical;
+      = local::ReleasePrimitiveArrayCritical;
   envTable->RegisterNatives = local::RegisterNatives;
   envTable->UnregisterNatives = local::UnregisterNatives;
   envTable->MonitorEnter = local::MonitorEnter;
@@ -3775,23 +3577,22 @@ populateJNITables(JavaVMVTable* vmTable, JNIEnvVTable* envTable)
   envTable->ToReflectedField = local::ToReflectedField;
 }
 
-} // namespace vm
+}  // namespace vm
 
-extern "C" AVIAN_EXPORT jint JNICALL
-JNI_GetDefaultJavaVMInitArgs(void*)
+extern "C" AVIAN_EXPORT jint JNICALL JNI_GetDefaultJavaVMInitArgs(void*)
 {
   return 0;
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-JNI_GetCreatedJavaVMs(Machine**, jsize, jsize*)
+    JNI_GetCreatedJavaVMs(Machine**, jsize, jsize*)
 {
   // todo
   return -1;
 }
 
 extern "C" AVIAN_EXPORT jint JNICALL
-JNI_CreateJavaVM(Machine** m, Thread** t, void* args)
+    JNI_CreateJavaVM(Machine** m, Thread** t, void* args)
 {
   local::JavaVMInitArgs* a = static_cast<local::JavaVMInitArgs*>(args);
 
@@ -3815,58 +3616,56 @@ JNI_CreateJavaVM(Machine** m, Thread** t, void* args)
         heapLimit = local::parseSize(p + 2);
       } else if (strncmp(p, "ss", 2) == 0) {
         stackLimit = local::parseSize(p + 2);
-      } else if (strncmp(p, BOOTCLASSPATH_PREPEND_OPTION ":",
-                         sizeof(BOOTCLASSPATH_PREPEND_OPTION)) == 0)
-      {
+      } else if (strncmp(p,
+                         BOOTCLASSPATH_PREPEND_OPTION ":",
+                         sizeof(BOOTCLASSPATH_PREPEND_OPTION)) == 0) {
         bootClasspathPrepend = p + sizeof(BOOTCLASSPATH_PREPEND_OPTION);
-      } else if (strncmp(p, BOOTCLASSPATH_OPTION ":",
-                         sizeof(BOOTCLASSPATH_OPTION)) == 0)
-      {
+      } else if (strncmp(
+                     p, BOOTCLASSPATH_OPTION ":", sizeof(BOOTCLASSPATH_OPTION))
+                 == 0) {
         bootClasspath = p + sizeof(BOOTCLASSPATH_OPTION);
-      } else if (strncmp(p, BOOTCLASSPATH_APPEND_OPTION ":",
-                         sizeof(BOOTCLASSPATH_APPEND_OPTION)) == 0)
-      {
+      } else if (strncmp(p,
+                         BOOTCLASSPATH_APPEND_OPTION ":",
+                         sizeof(BOOTCLASSPATH_APPEND_OPTION)) == 0) {
         bootClasspathAppend = p + sizeof(BOOTCLASSPATH_APPEND_OPTION);
       }
     } else if (strncmp(a->options[i].optionString, "-D", 2) == 0) {
       const char* p = a->options[i].optionString + 2;
-      if (strncmp(p, BOOTSTRAP_PROPERTY "=",
-                  sizeof(BOOTSTRAP_PROPERTY)) == 0)
-      {
+      if (strncmp(p, BOOTSTRAP_PROPERTY "=", sizeof(BOOTSTRAP_PROPERTY)) == 0) {
         bootLibraries = p + sizeof(BOOTSTRAP_PROPERTY);
-      } else if (strncmp(p, JAVA_COMMAND_PROPERTY "=",
+      } else if (strncmp(p,
+                         JAVA_COMMAND_PROPERTY "=",
                          sizeof(JAVA_COMMAND_PROPERTY)) == 0
-                 or strncmp(p, JAVA_LAUNCHER_PROPERTY "=",
-                            sizeof(JAVA_LAUNCHER_PROPERTY)) == 0)
-      {
+                 or strncmp(p,
+                            JAVA_LAUNCHER_PROPERTY "=",
+                            sizeof(JAVA_LAUNCHER_PROPERTY)) == 0) {
         // this means we're being invoked via the javac or java
         // command, so the bootstrap library should be e.g. libjvm.so
         bootLibraries = SO_PREFIX "jvm" SO_SUFFIX;
-      } else if (strncmp(p, CRASHDIR_PROPERTY "=",
-                         sizeof(CRASHDIR_PROPERTY)) == 0)
-      {
+      } else if (strncmp(p, CRASHDIR_PROPERTY "=", sizeof(CRASHDIR_PROPERTY))
+                 == 0) {
         crashDumpDirectory = p + sizeof(CRASHDIR_PROPERTY);
-      } else if (strncmp(p, CLASSPATH_PROPERTY "=",
-                         sizeof(CLASSPATH_PROPERTY)) == 0)
-      {
+      } else if (strncmp(p, CLASSPATH_PROPERTY "=", sizeof(CLASSPATH_PROPERTY))
+                 == 0) {
         classpath = p + sizeof(CLASSPATH_PROPERTY);
-      } else if (strncmp(p, JAVA_HOME_PROPERTY "=",
-                         sizeof(JAVA_HOME_PROPERTY)) == 0)
-      {
+      } else if (strncmp(p, JAVA_HOME_PROPERTY "=", sizeof(JAVA_HOME_PROPERTY))
+                 == 0) {
         javaHome = p + sizeof(JAVA_HOME_PROPERTY);
-      } else if (strncmp(p, EMBED_PREFIX_PROPERTY "=",
-                         sizeof(EMBED_PREFIX_PROPERTY)) == 0)
-      {
+      } else if (strncmp(p,
+                         EMBED_PREFIX_PROPERTY "=",
+                         sizeof(EMBED_PREFIX_PROPERTY)) == 0) {
         embedPrefix = p + sizeof(EMBED_PREFIX_PROPERTY);
       }
 
-      ++ propertyCount;
+      ++propertyCount;
     }
   }
 
-  if (heapLimit == 0) heapLimit = 128 * 1024 * 1024;
+  if (heapLimit == 0)
+    heapLimit = 128 * 1024 * 1024;
 
-  if (stackLimit == 0) stackLimit = 128 * 1024;
+  if (stackLimit == 0)
+    stackLimit = 128 * 1024;
 
   bool addClasspathProperty = classpath == 0;
   if (addClasspathProperty) {
@@ -3890,10 +3689,12 @@ JNI_CreateJavaVM(Machine** m, Thread** t, void* args)
   RUNTIME_ARRAY(char, bootClasspathBuffer, bootClasspathBufferSize);
   char* bootClasspathPointer = RUNTIME_ARRAY_BODY(bootClasspathBuffer);
   if (bootClasspathBufferSize > 3) {
-    local::append(&bootClasspathPointer, bootClasspathPrepend, bcppl,
+    local::append(&bootClasspathPointer,
+                  bootClasspathPrepend,
+                  bcppl,
                   bcpl + bcpal ? PATH_SEPARATOR : 0);
-    local::append(&bootClasspathPointer, bootClasspath, bcpl,
-                  bcpal ? PATH_SEPARATOR : 0);
+    local::append(
+        &bootClasspathPointer, bootClasspath, bcpl, bcpal ? PATH_SEPARATOR : 0);
     local::append(&bootClasspathPointer, bootClasspathAppend, bcpal, 0);
   } else {
     *RUNTIME_ARRAY_BODY(bootClasspathBuffer) = 0;
@@ -3901,26 +3702,26 @@ JNI_CreateJavaVM(Machine** m, Thread** t, void* args)
 
   char* bootLibrary = bootLibraries ? strdup(bootLibraries) : 0;
   char* bootLibraryEnd = bootLibrary ? strchr(bootLibrary, PATH_SEPARATOR) : 0;
-  if(bootLibraryEnd)
+  if (bootLibraryEnd)
     *bootLibraryEnd = 0;
 
-  Finder* bf = makeFinder
-    (s, h, RUNTIME_ARRAY_BODY(bootClasspathBuffer), bootLibrary);
+  Finder* bf
+      = makeFinder(s, h, RUNTIME_ARRAY_BODY(bootClasspathBuffer), bootLibrary);
   Finder* af = makeFinder(s, h, classpath, bootLibrary);
-  if(bootLibrary)
+  if (bootLibrary)
     free(bootLibrary);
   Processor* p = makeProcessor(s, h, crashDumpDirectory, true);
 
   // reserve space for avian.version and file.encoding:
   propertyCount += 2;
 
-  const char** properties = static_cast<const char**>
-    (h->allocate(sizeof(const char*) * propertyCount));
+  const char** properties = static_cast<const char**>(
+      h->allocate(sizeof(const char*) * propertyCount));
 
   const char** propertyPointer = properties;
 
-  const char** arguments = static_cast<const char**>
-    (h->allocate(sizeof(const char*) * a->nOptions));
+  const char** arguments = static_cast<const char**>(
+      h->allocate(sizeof(const char*) * a->nOptions));
 
   const char** argumentPointer = arguments;
 
@@ -3946,9 +3747,17 @@ JNI_CreateJavaVM(Machine** m, Thread** t, void* args)
   // overrideable via JavaVMInitArgs?
   *(propertyPointer++) = "file.encoding=UTF-8";
 
-  *m = new (h->allocate(sizeof(Machine))) Machine
-    (s, h, bf, af, p, c, properties, propertyCount, arguments, a->nOptions,
-     stackLimit);
+  *m = new (h->allocate(sizeof(Machine))) Machine(s,
+                                                  h,
+                                                  bf,
+                                                  af,
+                                                  p,
+                                                  c,
+                                                  properties,
+                                                  propertyCount,
+                                                  arguments,
+                                                  a->nOptions,
+                                                  stackLimit);
 
   h->free(properties, sizeof(const char*) * propertyCount);
 
diff --git a/src/lzma-decode.cpp b/src/lzma-decode.cpp
index e5fb4e7ec0..a1af7ae9fc 100644
--- a/src/lzma-decode.cpp
+++ b/src/lzma-decode.cpp
@@ -15,22 +15,22 @@ using namespace vm;
 
 namespace {
 
-int32_t
-read4(const uint8_t* in)
+int32_t read4(const uint8_t* in)
 {
   return (static_cast<int32_t>(in[3]) << 24)
-    |    (static_cast<int32_t>(in[2]) << 16)
-    |    (static_cast<int32_t>(in[1]) <<  8)
-    |    (static_cast<int32_t>(in[0])      );
+         | (static_cast<int32_t>(in[2]) << 16)
+         | (static_cast<int32_t>(in[1]) << 8) | (static_cast<int32_t>(in[0]));
 }
 
-} // namespace
+}  // namespace
 
 namespace vm {
 
-uint8_t*
-decodeLZMA(System* s, avian::util::Allocator* a, uint8_t* in, unsigned inSize,
-           unsigned* outSize)
+uint8_t* decodeLZMA(System* s,
+                    avian::util::Allocator* a,
+                    uint8_t* in,
+                    unsigned inSize,
+                    unsigned* outSize)
 {
   const unsigned PropHeaderSize = 5;
   const unsigned HeaderSize = 13;
@@ -45,9 +45,15 @@ decodeLZMA(System* s, avian::util::Allocator* a, uint8_t* in, unsigned inSize,
   LzmaAllocator allocator(a);
 
   ELzmaStatus status;
-  int result = LzmaDecode
-    (out, &outSizeT, in + HeaderSize, &inSizeT, in, PropHeaderSize,
-     LZMA_FINISH_END, &status, &(allocator.allocator));
+  int result = LzmaDecode(out,
+                          &outSizeT,
+                          in + HeaderSize,
+                          &inSizeT,
+                          in,
+                          PropHeaderSize,
+                          LZMA_FINISH_END,
+                          &status,
+                          &(allocator.allocator));
 
   expect(s, result == SZ_OK);
   expect(s, status == LZMA_STATUS_FINISHED_WITH_MARK);
@@ -57,5 +63,4 @@ decodeLZMA(System* s, avian::util::Allocator* a, uint8_t* in, unsigned inSize,
   return out;
 }
 
-} // namespace vm
-
+}  // namespace vm
diff --git a/src/lzma-encode.cpp b/src/lzma-encode.cpp
index 015086c194..8dc26586a3 100644
--- a/src/lzma-encode.cpp
+++ b/src/lzma-encode.cpp
@@ -15,19 +15,20 @@ using namespace vm;
 
 namespace {
 
-SRes
-myProgress(void*, UInt64, UInt64)
+SRes myProgress(void*, UInt64, UInt64)
 {
   return SZ_OK;
 }
 
-} // namespace
+}  // namespace
 
 namespace vm {
 
-uint8_t*
-encodeLZMA(System* s, Allocator* a, uint8_t* in, unsigned inSize,
-           unsigned* outSize)
+uint8_t* encodeLZMA(System* s,
+                    Allocator* a,
+                    uint8_t* in,
+                    unsigned inSize,
+                    unsigned* outSize)
 {
   const unsigned PropHeaderSize = 5;
   const unsigned HeaderSize = 13;
@@ -43,17 +44,25 @@ encodeLZMA(System* s, Allocator* a, uint8_t* in, unsigned inSize,
   props.level = 9;
   props.writeEndMark = 1;
 
-  ICompressProgress progress = { myProgress };
+  ICompressProgress progress = {myProgress};
 
   SizeT propsSize = PropHeaderSize;
 
   int32_t inSize32 = inSize;
   memcpy(buffer + PropHeaderSize, &inSize32, 4);
-          
+
   SizeT outSizeT = bufferSize;
-  int result = LzmaEncode
-    (buffer + HeaderSize, &outSizeT, in, inSize, &props, buffer,
-     &propsSize, 1, &progress, &(allocator.allocator), &(allocator.allocator));
+  int result = LzmaEncode(buffer + HeaderSize,
+                          &outSizeT,
+                          in,
+                          inSize,
+                          &props,
+                          buffer,
+                          &propsSize,
+                          1,
+                          &progress,
+                          &(allocator.allocator),
+                          &(allocator.allocator));
 
   expect(s, result == SZ_OK);
 
@@ -67,5 +76,4 @@ encodeLZMA(System* s, Allocator* a, uint8_t* in, unsigned inSize,
   return out;
 }
 
-} // namespace vm
-
+}  // namespace vm
diff --git a/src/lzma/load.cpp b/src/lzma/load.cpp
index 4a68466772..3f177e6b39 100644
--- a/src/lzma/load.cpp
+++ b/src/lzma/load.cpp
@@ -9,69 +9,62 @@
 #include "C/LzmaDec.h"
 
 #if (defined __MINGW32__) || (defined _MSC_VER)
-#  define EXPORT __declspec(dllexport)
-#  include <io.h>
-#  define open _open
-#  define write _write
-#  define close _close
-#  ifdef _MSC_VER
-#    define S_IRWXU (_S_IREAD | _S_IWRITE)
-#    define and &&
-#  endif
+#define EXPORT __declspec(dllexport)
+#include <io.h>
+#define open _open
+#define write _write
+#define close _close
+#ifdef _MSC_VER
+#define S_IRWXU (_S_IREAD | _S_IWRITE)
+#define and &&
+#endif
 #else
-#  define EXPORT __attribute__ ((visibility("default")))
-#  include <dlfcn.h>
-#  include <unistd.h>
-#  include <errno.h>
-#  define O_BINARY 0
+#define EXPORT __attribute__((visibility("default")))
+#include <dlfcn.h>
+#include <unistd.h>
+#include <errno.h>
+#define O_BINARY 0
 #endif
 
-#if (! defined __x86_64__) && ((defined __MINGW32__) || (defined _MSC_VER))
-#  define SYMBOL(x) binary_exe_##x
+#if (!defined __x86_64__) && ((defined __MINGW32__) || (defined _MSC_VER))
+#define SYMBOL(x) binary_exe_##x
 #else
-#  define SYMBOL(x) _binary_exe_##x
+#define SYMBOL(x) _binary_exe_##x
 #endif
 
 extern "C" {
+extern const uint8_t SYMBOL(start)[];
+extern const uint8_t SYMBOL(end)[];
 
-  extern const uint8_t SYMBOL(start)[];
-  extern const uint8_t SYMBOL(end)[];
-
-} // extern "C"
+}  // extern "C"
 
 namespace {
 
-int32_t
-read4(const uint8_t* in)
+int32_t read4(const uint8_t* in)
 {
   return (static_cast<int32_t>(in[3]) << 24)
-    |    (static_cast<int32_t>(in[2]) << 16)
-    |    (static_cast<int32_t>(in[1]) <<  8)
-    |    (static_cast<int32_t>(in[0])      );
+         | (static_cast<int32_t>(in[2]) << 16)
+         | (static_cast<int32_t>(in[1]) << 8) | (static_cast<int32_t>(in[0]));
 }
 
-void*
-myAllocate(void*, size_t size)
+void* myAllocate(void*, size_t size)
 {
   return malloc(size);
 }
 
-void
-myFree(void*, void* address)
+void myFree(void*, void* address)
 {
   free(address);
 }
 
 #if (defined __MINGW32__) || (defined _MSC_VER)
 
-void*
-openLibrary(const char* name)
+void* openLibrary(const char* name)
 {
   return LoadLibrary(name);
 }
 
-void*
-librarySymbol(void* library, const char* name)
+void* librarySymbol(void* library, const char* name)
 {
   void* address;
   FARPROC p = GetProcAddress(static_cast<HMODULE>(library), name);
@@ -79,14 +72,12 @@ librarySymbol(void* library, const char* name)
   return address;
 }
 
-const char*
-libraryError(void*)
+const char* libraryError(void*)
 {
   return "unknown error";
 }
 
-const char*
-temporaryFileName(char* buffer, unsigned size)
+const char* temporaryFileName(char* buffer, unsigned size)
 {
   unsigned c = GetTempPathA(size, buffer);
   if (c) {
@@ -100,36 +91,31 @@ temporaryFileName(char* buffer, unsigned size)
 
 #else
 
-void*
-openLibrary(const char* name)
+void* openLibrary(const char* name)
 {
   return dlopen(name, RTLD_LAZY | RTLD_LOCAL);
 }
 
-void*
-librarySymbol(void* library, const char* name)
+void* librarySymbol(void* library, const char* name)
 {
   return dlsym(library, name);
 }
 
-const char*
-libraryError(void*)
+const char* libraryError(void*)
 {
   return dlerror();
 }
 
-const char*
-temporaryFileName(char* buffer, unsigned)
+const char* temporaryFileName(char* buffer, unsigned)
 {
   return tmpnam(buffer);
 }
 
 #endif
 
-} // namespace
+}  // namespace
 
-int
-main(int ac, const char** av)
+int main(int ac, const char** av)
 {
   const unsigned PropHeaderSize = 5;
   const unsigned HeaderSize = 13;
@@ -141,13 +127,18 @@ main(int ac, const char** av)
 
   uint8_t* out = static_cast<uint8_t*>(malloc(outSize));
   if (out) {
-    ISzAlloc allocator = { myAllocate, myFree };
+    ISzAlloc allocator = {myAllocate, myFree};
     ELzmaStatus status = LZMA_STATUS_NOT_SPECIFIED;
 
-    if (SZ_OK == LzmaDecode
-        (out, &outSize, SYMBOL(start) + HeaderSize, &inSize, SYMBOL(start),
-         PropHeaderSize, LZMA_FINISH_END, &status, &allocator))
-    {
+    if (SZ_OK == LzmaDecode(out,
+                            &outSize,
+                            SYMBOL(start) + HeaderSize,
+                            &inSize,
+                            SYMBOL(start),
+                            PropHeaderSize,
+                            LZMA_FINISH_END,
+                            &status,
+                            &allocator)) {
       const unsigned BufferSize = 1024;
       char buffer[BufferSize];
       const char* name = temporaryFileName(buffer, BufferSize);
@@ -171,14 +162,18 @@ main(int ac, const char** av)
                 fprintf(stderr, "unable to find main in %s", name);
               }
             } else {
-              fprintf(stderr, "unable to load %s: %s\n", name,
+              fprintf(stderr,
+                      "unable to load %s: %s\n",
+                      name,
                       libraryError(library));
             }
           } else {
             unlink(name);
 
-            fprintf(stderr, "close or write failed; tried %d, got %d; %s\n",
-                    static_cast<int>(outSize), static_cast<int>(result),
+            fprintf(stderr,
+                    "close or write failed; tried %d, got %d; %s\n",
+                    static_cast<int>(outSize),
+                    static_cast<int>(result),
                     strerror(errno));
           }
         } else {
@@ -191,7 +186,8 @@ main(int ac, const char** av)
       fprintf(stderr, "unable to decode LZMA data\n");
     }
   } else {
-    fprintf(stderr, "unable to allocate buffer of size %d\n",
+    fprintf(stderr,
+            "unable to allocate buffer of size %d\n",
             static_cast<int>(outSize));
   }
 
diff --git a/src/lzma/main.cpp b/src/lzma/main.cpp
index f6baa39bb9..daf75c9cde 100644
--- a/src/lzma/main.cpp
+++ b/src/lzma/main.cpp
@@ -17,46 +17,40 @@
 
 namespace {
 
-int32_t
-read4(const uint8_t* in)
+int32_t read4(const uint8_t* in)
 {
   return (static_cast<int32_t>(in[3]) << 24)
-    |    (static_cast<int32_t>(in[2]) << 16)
-    |    (static_cast<int32_t>(in[1]) <<  8)
-    |    (static_cast<int32_t>(in[0])      );
+         | (static_cast<int32_t>(in[2]) << 16)
+         | (static_cast<int32_t>(in[1]) << 8) | (static_cast<int32_t>(in[0]));
 }
 
-void*
-myAllocate(void*, size_t size)
+void* myAllocate(void*, size_t size)
 {
   return malloc(size);
 }
 
-void
-myFree(void*, void* address)
+void myFree(void*, void* address)
 {
   free(address);
 }
 
-SRes
-myProgress(void*, UInt64, UInt64)
+SRes myProgress(void*, UInt64, UInt64)
 {
   return SZ_OK;
 }
 
-void
-usageAndExit(const char* program)
+void usageAndExit(const char* program)
 {
   fprintf(stderr,
           "usage: %s {encode|decode} <input file> <output file> "
-          "[<uncompressed size>]", program);
+          "[<uncompressed size>]",
+          program);
   exit(-1);
 }
 
-} // namespace
+}  // namespace
 
-int
-main(int argc, const char** argv)
+int main(int argc, const char** argv)
 {
   if (argc < 4 or argc > 5) {
     usageAndExit(argv[0]);
@@ -73,26 +67,16 @@ main(int argc, const char** argv)
     if (r != -1) {
 #ifdef WIN32
       HANDLE fm;
-      HANDLE h = (HANDLE) _get_osfhandle (fd);
+      HANDLE h = (HANDLE)_get_osfhandle(fd);
 
-      fm = CreateFileMapping(
-               h,
-               NULL,
-               PAGE_READONLY,
-               0,
-               0,
-               NULL);
-      data = static_cast<uint8_t*>(MapViewOfFile(
-                fm,
-                FILE_MAP_READ,
-                0,
-                0,
-                s.st_size));
+      fm = CreateFileMapping(h, NULL, PAGE_READONLY, 0, 0, NULL);
+      data = static_cast<uint8_t*>(
+          MapViewOfFile(fm, FILE_MAP_READ, 0, 0, s.st_size));
 
       CloseHandle(fm);
 #else
-      data = static_cast<uint8_t*>
-        (mmap(0, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0));
+      data = static_cast<uint8_t*>(
+          mmap(0, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0));
 #endif
       size = s.st_size;
     }
@@ -123,7 +107,7 @@ main(int argc, const char** argv)
       uint8_t* out = static_cast<uint8_t*>(malloc(outSize));
       if (out) {
         SizeT inSize = size;
-        ISzAlloc allocator = { myAllocate, myFree };
+        ISzAlloc allocator = {myAllocate, myFree};
         ELzmaStatus status = LZMA_STATUS_NOT_SPECIFIED;
         int result;
         if (encode) {
@@ -132,22 +116,36 @@ main(int argc, const char** argv)
           props.level = 9;
           props.writeEndMark = 1;
 
-          ICompressProgress progress = { myProgress };
+          ICompressProgress progress = {myProgress};
 
           SizeT propsSize = PropHeaderSize;
 
           int32_t inSize32 = inSize;
           memcpy(out + PropHeaderSize, &inSize32, 4);
-          
-          result = LzmaEncode
-            (out + HeaderSize, &outSize, data, inSize, &props, out,
-             &propsSize, 1, &progress, &allocator, &allocator);
+
+          result = LzmaEncode(out + HeaderSize,
+                              &outSize,
+                              data,
+                              inSize,
+                              &props,
+                              out,
+                              &propsSize,
+                              1,
+                              &progress,
+                              &allocator,
+                              &allocator);
 
           outSize += HeaderSize;
         } else {
-          result = LzmaDecode
-            (out, &outSize, data + HeaderSize, &inSize, data, PropHeaderSize,
-             LZMA_FINISH_END, &status, &allocator);
+          result = LzmaDecode(out,
+                              &outSize,
+                              data + HeaderSize,
+                              &inSize,
+                              data,
+                              PropHeaderSize,
+                              LZMA_FINISH_END,
+                              &status,
+                              &allocator);
         }
 
         if (result == SZ_OK) {
@@ -165,8 +163,11 @@ main(int argc, const char** argv)
             fprintf(stderr, "unable to open %s\n", argv[3]);
           }
         } else {
-          fprintf(stderr, "unable to %s data: result %d status %d\n",
-                  encode ? "encode" : "decode", result, status);
+          fprintf(stderr,
+                  "unable to %s data: result %d status %d\n",
+                  encode ? "encode" : "decode",
+                  result,
+                  status);
         }
 
         free(out);
diff --git a/src/machine.cpp b/src/machine.cpp
index de813044bd..82d95a6629 100644
--- a/src/machine.cpp
+++ b/src/machine.cpp
@@ -21,8 +21,8 @@
 #include <avian/util/math.h>
 
 #if defined(PLATFORM_WINDOWS)
-#  define WIN32_LEAN_AND_MEAN
-#  include <windows.h>
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
 #endif
 
 using namespace vm;
@@ -35,18 +35,15 @@ const bool DebugClassReader = false;
 const unsigned NoByte = 0xFFFF;
 
 #ifdef USE_ATOMIC_OPERATIONS
-void
-atomicIncrement(uint32_t* p, int v)
+void atomicIncrement(uint32_t* p, int v)
 {
-  for (uint32_t old = *p;
-       not atomicCompareAndSwap32(p, old, old + v);
-       old = *p)
-  { }
+  for (uint32_t old = *p; not atomicCompareAndSwap32(p, old, old + v);
+       old = *p) {
+  }
 }
 #endif
 
-void
-join(Thread* t, Thread* o)
+void join(Thread* t, Thread* o)
 {
   if (t != o) {
     assertT(t, o->state != Thread::JoinedState);
@@ -60,40 +57,41 @@ join(Thread* t, Thread* o)
 
 #ifndef NDEBUG
 
-bool
-find(Thread* t, Thread* o)
+bool find(Thread* t, Thread* o)
 {
-  return (t == o)
-    or (t->peer and find(t->peer, o))
-    or (t->child and find(t->child, o));
+  return (t == o) or (t->peer and find(t->peer, o))
+         or (t->child and find(t->child, o));
 }
 
-unsigned
-count(Thread* t, Thread* o)
+unsigned count(Thread* t, Thread* o)
 {
   unsigned c = 0;
 
-  if (t != o) ++ c;
-  if (t->peer) c += count(t->peer, o);
-  if (t->child) c += count(t->child, o);
+  if (t != o)
+    ++c;
+  if (t->peer)
+    c += count(t->peer, o);
+  if (t->child)
+    c += count(t->child, o);
 
   return c;
 }
 
-Thread**
-fill(Thread* t, Thread* o, Thread** array)
+Thread** fill(Thread* t, Thread* o, Thread** array)
 {
-  if (t != o) *(array++) = t;
-  if (t->peer) array = fill(t->peer, o, array);
-  if (t->child) array = fill(t->child, o, array);
+  if (t != o)
+    *(array++) = t;
+  if (t->peer)
+    array = fill(t->peer, o, array);
+  if (t->child)
+    array = fill(t->child, o, array);
 
   return array;
 }
 
-#endif // not NDEBUG
+#endif  // not NDEBUG
 
-void
-dispose(Thread* t, Thread* o, bool remove)
+void dispose(Thread* t, Thread* o, bool remove)
 {
   if (remove) {
 #ifndef NDEBUG
@@ -118,7 +116,7 @@ dispose(Thread* t, Thread* o, bool remove)
           previous = p;
           p = p->peer;
         }
-      }      
+      }
 
       for (Thread* p = o->child; p;) {
         Thread* next = p->peer;
@@ -154,8 +152,7 @@ dispose(Thread* t, Thread* o, bool remove)
   o->dispose();
 }
 
-void
-visitAll(Thread* m, Thread* o, void (*visit)(Thread*, Thread*))
+void visitAll(Thread* m, Thread* o, void (*visit)(Thread*, Thread*))
 {
   for (Thread* p = o->child; p;) {
     Thread* child = p;
@@ -166,22 +163,19 @@ visitAll(Thread* m, Thread* o, void (*visit)(Thread*, Thread*))
   visit(m, o);
 }
 
-void
-disposeNoRemove(Thread* m, Thread* o)
+void disposeNoRemove(Thread* m, Thread* o)
 {
   dispose(m, o, false);
 }
 
-void
-interruptDaemon(Thread* m, Thread* o)
+void interruptDaemon(Thread* m, Thread* o)
 {
   if (o->flags & Thread::DaemonFlag) {
     interrupt(m, o);
   }
 }
 
-void
-turnOffTheLights(Thread* t)
+void turnOffTheLights(Thread* t)
 {
   expect(t, t->m->liveCount == 1);
 
@@ -255,8 +249,7 @@ turnOffTheLights(Thread* t)
   s->dispose();
 }
 
-void
-killZombies(Thread* t, Thread* o)
+void killZombies(Thread* t, Thread* o)
 {
   for (Thread* p = o->child; p;) {
     Thread* child = p;
@@ -268,18 +261,18 @@ killZombies(Thread* t, Thread* o)
     switch (o->state) {
     case Thread::ZombieState:
       join(t, o);
-      // fall through
-      
+    // fall through
+
     case Thread::JoinedState:
       dispose(t, o, true);
-      
-    default: break;
+
+    default:
+      break;
     }
   }
 }
 
-unsigned
-footprint(Thread* t)
+unsigned footprint(Thread* t)
 {
   expect(t, t->criticalLevel == 0);
 
@@ -292,8 +285,7 @@ footprint(Thread* t)
   return n;
 }
 
-void
-visitRoots(Thread* t, Heap::Visitor* v)
+void visitRoots(Thread* t, Heap::Visitor* v)
 {
   if (t->state != Thread::ZombieState) {
     v->visit(&(t->javaThread));
@@ -311,13 +303,17 @@ visitRoots(Thread* t, Heap::Visitor* v)
   }
 }
 
-bool
-walk(Thread*, Heap::Walker* w, uint32_t* mask, unsigned fixedSize,
-     unsigned arrayElementSize, unsigned arrayLength, unsigned start)
+bool walk(Thread*,
+          Heap::Walker* w,
+          uint32_t* mask,
+          unsigned fixedSize,
+          unsigned arrayElementSize,
+          unsigned arrayLength,
+          unsigned start)
 {
   unsigned fixedSizeInWords = ceilingDivide(fixedSize, BytesPerWord);
   unsigned arrayElementSizeInWords
-    = ceilingDivide(arrayElementSize, BytesPerWord);
+      = ceilingDivide(arrayElementSize, BytesPerWord);
 
   for (unsigned i = start; i < fixedSizeInWords; ++i) {
     if (mask[i / 32] & (static_cast<uint32_t>(1) << (i % 32))) {
@@ -352,9 +348,8 @@ walk(Thread*, Heap::Walker* w, uint32_t* mask, unsigned fixedSize,
       for (unsigned j = elementStart; j < arrayElementSizeInWords; ++j) {
         unsigned k = fixedSizeInWords + j;
         if (mask[k / 32] & (static_cast<uint32_t>(1) << (k % 32))) {
-          if (not w->visit
-              (fixedSizeInWords + (i * arrayElementSizeInWords) + j))
-          {
+          if (not w->visit(fixedSizeInWords + (i * arrayElementSizeInWords)
+                           + j)) {
             return false;
           }
         }
@@ -477,8 +472,7 @@ void referenceTargetReachable(Thread* t, Heap::Visitor* v, GcJreference** p)
   }
 }
 
-bool
-isFinalizable(Thread* t, object o)
+bool isFinalizable(Thread* t, object o)
 {
   return t->m->heap->status(o) == Heap::Unreachable
          and (t->m->heap->follow(objectClass(t, o))->vmFlags()
@@ -492,8 +486,7 @@ void clearTargetIfFinalizable(Thread* t, GcJreference* r)
   }
 }
 
-void
-postVisit(Thread* t, Heap::Visitor* v)
+void postVisit(Thread* t, Heap::Visitor* v)
 {
   Machine* m = t->m;
   bool major = m->heap->collectionType() == Heap::MajorCollection;
@@ -517,9 +510,9 @@ postVisit(Thread* t, Heap::Visitor* v)
   }
 
   for (Reference* r = m->jniReferences; r; r = r->next) {
-    if (r->weak and isFinalizable
-        (t, static_cast<object>(t->m->heap->follow(r->target))))
-    {
+    if (r->weak
+        and isFinalizable(t,
+                          static_cast<object>(t->m->heap->follow(r->target)))) {
       r->target = 0;
     }
   }
@@ -527,7 +520,8 @@ postVisit(Thread* t, Heap::Visitor* v)
   GcFinalizer* firstNewTenuredFinalizer = 0;
   GcFinalizer* lastNewTenuredFinalizer = 0;
 
-  { object unreachable = 0;
+  {
+    object unreachable = 0;
     for (GcFinalizer** p = &(m->finalizers); *p;) {
       v->visit(p);
 
@@ -604,7 +598,8 @@ postVisit(Thread* t, Heap::Visitor* v)
   }
 
   if (major) {
-    { object unreachable = 0;
+    {
+      object unreachable = 0;
       for (GcFinalizer** p = &(m->tenuredFinalizers); *p;) {
         v->visit(p);
 
@@ -668,13 +663,12 @@ postVisit(Thread* t, Heap::Visitor* v)
   }
 }
 
-void
-postCollect(Thread* t)
+void postCollect(Thread* t)
 {
 #ifdef VM_STRESS
   t->m->heap->free(t->defaultHeap, ThreadHeapSizeInBytes);
-  t->defaultHeap = static_cast<uintptr_t*>
-    (t->m->heap->allocate(ThreadHeapSizeInBytes));
+  t->defaultHeap
+      = static_cast<uintptr_t*>(t->m->heap->allocate(ThreadHeapSizeInBytes));
   memset(t->defaultHeap, 0, ThreadHeapSizeInBytes);
 #endif
 
@@ -707,8 +701,7 @@ postCollect(Thread* t)
   }
 }
 
-uint64_t
-invoke(Thread* t, uintptr_t* arguments)
+uint64_t invoke(Thread* t, uintptr_t* arguments)
 {
   GcMethod* m = cast<GcMethod>(t, *reinterpret_cast<object*>(arguments[0]));
   object o = *reinterpret_cast<object*>(arguments[1]);
@@ -718,8 +711,7 @@ invoke(Thread* t, uintptr_t* arguments)
   return 1;
 }
 
-void
-finalizeObject(Thread* t, object o, const char* name)
+void finalizeObject(Thread* t, object o, const char* name)
 {
   for (GcClass* c = objectClass(t, o); c; c = c->super()) {
     GcArray* mtable = cast<GcArray>(t, c->methodTable());
@@ -733,8 +725,8 @@ finalizeObject(Thread* t, object o, const char* name)
         PROTECT(t, m);
         PROTECT(t, o);
 
-        uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(&m),
-                                  reinterpret_cast<uintptr_t>(&o) };
+        uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(&m),
+                                 reinterpret_cast<uintptr_t>(&o)};
 
         run(t, invoke, arguments);
 
@@ -746,8 +738,7 @@ finalizeObject(Thread* t, object o, const char* name)
   abort(t);
 }
 
-unsigned
-readByte(AbstractStream& s, unsigned* value)
+unsigned readByte(AbstractStream& s, unsigned* value)
 {
   if (*value == NoByte) {
     return s.read1();
@@ -860,8 +851,7 @@ GcByteArray* makeByteArray(Thread* t, Stream& s, unsigned length)
   return value;
 }
 
-void
-removeByteArray(Thread* t, object o)
+void removeByteArray(Thread* t, object o)
 {
   hashMapRemove(t, roots(t)->byteArrayMap(), o, byteArrayHash, objectEqual);
 }
@@ -899,31 +889,34 @@ unsigned parsePoolEntry(Thread* t,
     uint32_t v = s.read4();
     singletonValue(t, pool, i) = v;
 
-    if(DebugClassReader) {
+    if (DebugClassReader) {
       fprintf(stderr, "    consts[%d] = int/float 0x%x\n", i, v);
     }
-  } return 1;
-    
+  }
+    return 1;
+
   case CONSTANT_Long:
   case CONSTANT_Double: {
     uint64_t v = s.read8();
     memcpy(&singletonValue(t, pool, i), &v, 8);
 
-    if(DebugClassReader) {
+    if (DebugClassReader) {
       fprintf(stderr, "    consts[%d] = long/double <todo>\n", i);
     }
-  } return 2;
+  }
+    return 2;
 
   case CONSTANT_Utf8: {
     if (singletonObject(t, pool, i) == 0) {
       GcByteArray* value = internByteArray(t, makeByteArray(t, s, s.read2()));
       pool->setBodyElement(t, i, reinterpret_cast<uintptr_t>(value));
 
-      if(DebugClassReader) {
+      if (DebugClassReader) {
         fprintf(stderr, "    consts[%d] = utf8 %s\n", i, value->body().begin());
       }
     }
-  } return 1;
+  }
+    return 1;
 
   case CONSTANT_Class: {
     if (singletonObject(t, pool, i) == 0) {
@@ -934,11 +927,12 @@ unsigned parsePoolEntry(Thread* t,
           t, 0, 0, cast<GcByteArray>(t, singletonObject(t, pool, si)), 0);
       pool->setBodyElement(t, i, reinterpret_cast<uintptr_t>(value));
 
-      if(DebugClassReader) {
+      if (DebugClassReader) {
         fprintf(stderr, "    consts[%d] = class <todo>\n", i);
       }
     }
-  } return 1;
+  }
+    return 1;
 
   case CONSTANT_String: {
     if (singletonObject(t, pool, i) == 0) {
@@ -947,16 +941,17 @@ unsigned parsePoolEntry(Thread* t,
 
       object value
           = parseUtf8(t, cast<GcByteArray>(t, singletonObject(t, pool, si)));
-      value = t->m->classpath->makeString
-        (t, value, 0, fieldAtOffset<uintptr_t>(value, BytesPerWord) - 1);
+      value = t->m->classpath->makeString(
+          t, value, 0, fieldAtOffset<uintptr_t>(value, BytesPerWord) - 1);
       value = intern(t, value);
       pool->setBodyElement(t, i, reinterpret_cast<uintptr_t>(value));
 
-      if(DebugClassReader) {
+      if (DebugClassReader) {
         fprintf(stderr, "    consts[%d] = string <todo>\n", i);
       }
     }
-  } return 1;
+  }
+    return 1;
 
   case CONSTANT_NameAndType: {
     if (singletonObject(t, pool, i) == 0) {
@@ -971,7 +966,7 @@ unsigned parsePoolEntry(Thread* t,
       GcPair* value = makePair(t, name, type);
       pool->setBodyElement(t, i, reinterpret_cast<uintptr_t>(value));
 
-      if(DebugClassReader) {
+      if (DebugClassReader) {
         fprintf(stderr,
                 "    consts[%d] = nameAndType %s%s\n",
                 i,
@@ -979,7 +974,8 @@ unsigned parsePoolEntry(Thread* t,
                 type->body().begin());
       }
     }
-  } return 1;
+  }
+    return 1;
 
   case CONSTANT_Fieldref:
   case CONSTANT_Methodref:
@@ -1002,7 +998,7 @@ unsigned parsePoolEntry(Thread* t,
                                    cast<GcByteArray>(t, nameAndType->second()));
       pool->setBodyElement(t, i, reinterpret_cast<uintptr_t>(value));
 
-      if(DebugClassReader) {
+      if (DebugClassReader) {
         fprintf(stderr,
                 "    consts[%d] = method %s.%s%s\n",
                 i,
@@ -1011,7 +1007,8 @@ unsigned parsePoolEntry(Thread* t,
                 cast<GcByteArray>(t, nameAndType->second())->body().begin());
       }
     }
-  } return 1;
+  }
+    return 1;
 
   case CONSTANT_MethodHandle:
     if (singletonObject(t, pool, i) == 0) {
@@ -1036,7 +1033,8 @@ unsigned parsePoolEntry(Thread* t,
           t, kind, value->class_(), value->name(), value->spec());
 
       pool->setBodyElement(t, i, reinterpret_cast<uintptr_t>(value));
-    } return 1;
+    }
+    return 1;
 
   case CONSTANT_MethodType:
     if (singletonObject(t, pool, i) == 0) {
@@ -1046,7 +1044,8 @@ unsigned parsePoolEntry(Thread* t,
 
       pool->setBodyElement(
           t, i, reinterpret_cast<uintptr_t>(singletonObject(t, pool, ni)));
-    } return 1;
+    }
+    return 1;
 
   case CONSTANT_InvokeDynamic:
     if (singletonObject(t, pool, i) == 0) {
@@ -1063,9 +1062,12 @@ unsigned parsePoolEntry(Thread* t,
       unsigned parameterCount;
       unsigned parameterFootprint;
       unsigned returnCode;
-      scanMethodSpec
-        (t, specString, true, &parameterCount, &parameterFootprint,
-         &returnCode);
+      scanMethodSpec(t,
+                     specString,
+                     true,
+                     &parameterCount,
+                     &parameterFootprint,
+                     &returnCode);
 
       GcMethod* template_
           = makeMethod(t,
@@ -1087,9 +1089,11 @@ unsigned parsePoolEntry(Thread* t,
           makeInvocation(t, bootstrap, -1, 0, pool, template_, 0));
 
       pool->setBodyElement(t, i, reinterpret_cast<uintptr_t>(value));
-    } return 1;
+    }
+    return 1;
 
-  default: abort(t);
+  default:
+    abort(t);
   }
 }
 
@@ -1099,14 +1103,18 @@ GcSingleton* parsePool(Thread* t, Stream& s)
   GcSingleton* pool = makeSingletonOfSize(t, count + poolMaskSize(count));
   PROTECT(t, pool);
 
-  if(DebugClassReader) {
+  if (DebugClassReader) {
     fprintf(stderr, "  const pool entries %d\n", count);
   }
 
   if (count) {
     uint32_t* index = static_cast<uint32_t*>(t->m->heap->allocate(count * 4));
 
-    THREAD_RESOURCE2(t, uint32_t*, index, unsigned, count,
+    THREAD_RESOURCE2(t,
+                     uint32_t*,
+                     index,
+                     unsigned,
+                     count,
                      t->m->heap->free(index, count * 4));
 
     for (unsigned i = 0; i < count; ++i) {
@@ -1138,14 +1146,14 @@ GcSingleton* parsePool(Thread* t, Stream& s)
 
       case CONSTANT_Long:
         s.skip(8);
-        ++ i;
+        ++i;
         break;
 
       case CONSTANT_Double:
         singletonSetBit(t, pool, count, i);
         singletonSetBit(t, pool, count, i + 1);
         s.skip(8);
-        ++ i;
+        ++i;
         break;
 
       case CONSTANT_Utf8:
@@ -1168,7 +1176,8 @@ GcSingleton* parsePool(Thread* t, Stream& s)
         s.skip(4);
         break;
 
-      default: abort(t);
+      default:
+        abort(t);
       }
     }
 
@@ -1275,7 +1284,7 @@ void parseInterfaceTable(Thread* t,
       GcClass* interface = cast<GcClass>(t, it.next()->second());
 
       interfaceTable->setBodyElement(t, i, interface);
-      ++ i;
+      ++i;
 
       if ((class_->flags() & ACC_INTERFACE) == 0) {
         if (GcArray* vt = cast<GcArray>(t, interface->virtualTable())) {
@@ -1406,8 +1415,8 @@ void parseFieldTable(Thread* t, Stream& s, GcClass* class_, GcSingleton* pool)
     class_->setFieldTable(t, fieldTable);
 
     if (staticCount) {
-      unsigned footprint = ceilingDivide(staticOffset - (BytesPerWord * 2),
-                                   BytesPerWord);
+      unsigned footprint
+          = ceilingDivide(staticOffset - (BytesPerWord * 2), BytesPerWord);
       GcSingleton* staticTable = makeSingletonOfSize(t, footprint);
 
       uint8_t* body = reinterpret_cast<uint8_t*>(staticTable->body().begin());
@@ -1430,13 +1439,13 @@ void parseFieldTable(Thread* t, Stream& s, GcClass* class_, GcSingleton* pool)
           case CharField:
           case ShortField:
             *reinterpret_cast<uint16_t*>(body + offset)
-              = singletonValue(t, pool, value - 1);
+                = singletonValue(t, pool, value - 1);
             break;
 
           case IntField:
           case FloatField:
             *reinterpret_cast<uint32_t*>(body + offset)
-              = singletonValue(t, pool, value - 1);
+                = singletonValue(t, pool, value - 1);
             break;
 
           case LongField:
@@ -1450,7 +1459,8 @@ void parseFieldTable(Thread* t, Stream& s, GcClass* class_, GcSingleton* pool)
                    BytesPerWord);
             break;
 
-          default: abort(t);
+          default:
+            abort(t);
           }
         }
 
@@ -1505,13 +1515,15 @@ void parseFieldTable(Thread* t, Stream& s, GcClass* class_, GcSingleton* pool)
   }
 }
 
-uint16_t read16(uint8_t* code, unsigned& ip) {
+uint16_t read16(uint8_t* code, unsigned& ip)
+{
   uint16_t a = code[ip++];
   uint16_t b = code[ip++];
   return (a << 8) | b;
 }
 
-uint32_t read32(uint8_t* code, unsigned& ip) {
+uint32_t read32(uint8_t* code, unsigned& ip)
+{
   uint32_t b = code[ip++];
   uint32_t a = code[ip++];
   uint32_t c = code[ip++];
@@ -1519,370 +1531,749 @@ uint32_t read32(uint8_t* code, unsigned& ip) {
   return (a << 24) | (b << 16) | (c << 8) | d;
 }
 
-void
-disassembleCode(const char* prefix, uint8_t* code, unsigned length)
+void disassembleCode(const char* prefix, uint8_t* code, unsigned length)
 {
   unsigned ip = 0;
 
-  while(ip < length) {
+  while (ip < length) {
     unsigned instr;
     fprintf(stderr, "%s%x:\t", prefix, ip);
     switch (instr = code[ip++]) {
-      case aaload: fprintf(stderr, "aaload\n"); break;
-      case aastore: fprintf(stderr, "aastore\n"); break;
+    case aaload:
+      fprintf(stderr, "aaload\n");
+      break;
+    case aastore:
+      fprintf(stderr, "aastore\n");
+      break;
 
-      case aconst_null: fprintf(stderr, "aconst_null\n"); break;
+    case aconst_null:
+      fprintf(stderr, "aconst_null\n");
+      break;
 
-      case aload: fprintf(stderr, "aload %02x\n", code[ip++]); break;
-      case aload_0: fprintf(stderr, "aload_0\n"); break;
-      case aload_1: fprintf(stderr, "aload_1\n"); break;
-      case aload_2: fprintf(stderr, "aload_2\n"); break;
-      case aload_3: fprintf(stderr, "aload_3\n"); break;
+    case aload:
+      fprintf(stderr, "aload %02x\n", code[ip++]);
+      break;
+    case aload_0:
+      fprintf(stderr, "aload_0\n");
+      break;
+    case aload_1:
+      fprintf(stderr, "aload_1\n");
+      break;
+    case aload_2:
+      fprintf(stderr, "aload_2\n");
+      break;
+    case aload_3:
+      fprintf(stderr, "aload_3\n");
+      break;
 
-      case anewarray: fprintf(stderr, "anewarray %04x\n", read16(code, ip)); break;
-      case areturn: fprintf(stderr, "areturn\n"); break;
-      case arraylength: fprintf(stderr, "arraylength\n"); break;
+    case anewarray:
+      fprintf(stderr, "anewarray %04x\n", read16(code, ip));
+      break;
+    case areturn:
+      fprintf(stderr, "areturn\n");
+      break;
+    case arraylength:
+      fprintf(stderr, "arraylength\n");
+      break;
 
-      case astore: fprintf(stderr, "astore %02x\n", code[ip++]); break;
-      case astore_0: fprintf(stderr, "astore_0\n"); break;
-      case astore_1: fprintf(stderr, "astore_1\n"); break;
-      case astore_2: fprintf(stderr, "astore_2\n"); break;
-      case astore_3: fprintf(stderr, "astore_3\n"); break;
+    case astore:
+      fprintf(stderr, "astore %02x\n", code[ip++]);
+      break;
+    case astore_0:
+      fprintf(stderr, "astore_0\n");
+      break;
+    case astore_1:
+      fprintf(stderr, "astore_1\n");
+      break;
+    case astore_2:
+      fprintf(stderr, "astore_2\n");
+      break;
+    case astore_3:
+      fprintf(stderr, "astore_3\n");
+      break;
 
+    case athrow:
+      fprintf(stderr, "athrow\n");
+      break;
+    case baload:
+      fprintf(stderr, "baload\n");
+      break;
+    case bastore:
+      fprintf(stderr, "bastore\n");
+      break;
 
-      case athrow: fprintf(stderr, "athrow\n"); break;
-      case baload: fprintf(stderr, "baload\n"); break;
-      case bastore: fprintf(stderr, "bastore\n"); break;
+    case bipush:
+      fprintf(stderr, "bipush %02x\n", code[ip++]);
+      break;
+    case caload:
+      fprintf(stderr, "caload\n");
+      break;
+    case castore:
+      fprintf(stderr, "castore\n");
+      break;
+    case checkcast:
+      fprintf(stderr, "checkcast %04x\n", read16(code, ip));
+      break;
+    case d2f:
+      fprintf(stderr, "d2f\n");
+      break;
+    case d2i:
+      fprintf(stderr, "d2i\n");
+      break;
+    case d2l:
+      fprintf(stderr, "d2l\n");
+      break;
+    case dadd:
+      fprintf(stderr, "dadd\n");
+      break;
+    case daload:
+      fprintf(stderr, "daload\n");
+      break;
+    case dastore:
+      fprintf(stderr, "dastore\n");
+      break;
+    case dcmpg:
+      fprintf(stderr, "dcmpg\n");
+      break;
+    case dcmpl:
+      fprintf(stderr, "dcmpl\n");
+      break;
+    case dconst_0:
+      fprintf(stderr, "dconst_0\n");
+      break;
+    case dconst_1:
+      fprintf(stderr, "dconst_1\n");
+      break;
+    case ddiv:
+      fprintf(stderr, "ddiv\n");
+      break;
+    case dmul:
+      fprintf(stderr, "dmul\n");
+      break;
+    case dneg:
+      fprintf(stderr, "dneg\n");
+      break;
+    case vm::drem:
+      fprintf(stderr, "drem\n");
+      break;
+    case dsub:
+      fprintf(stderr, "dsub\n");
+      break;
+    case vm::dup:
+      fprintf(stderr, "dup\n");
+      break;
+    case dup_x1:
+      fprintf(stderr, "dup_x1\n");
+      break;
+    case dup_x2:
+      fprintf(stderr, "dup_x2\n");
+      break;
+    case vm::dup2:
+      fprintf(stderr, "dup2\n");
+      break;
+    case dup2_x1:
+      fprintf(stderr, "dup2_x1\n");
+      break;
+    case dup2_x2:
+      fprintf(stderr, "dup2_x2\n");
+      break;
+    case f2d:
+      fprintf(stderr, "f2d\n");
+      break;
+    case f2i:
+      fprintf(stderr, "f2i\n");
+      break;
+    case f2l:
+      fprintf(stderr, "f2l\n");
+      break;
+    case fadd:
+      fprintf(stderr, "fadd\n");
+      break;
+    case faload:
+      fprintf(stderr, "faload\n");
+      break;
+    case fastore:
+      fprintf(stderr, "fastore\n");
+      break;
+    case fcmpg:
+      fprintf(stderr, "fcmpg\n");
+      break;
+    case fcmpl:
+      fprintf(stderr, "fcmpl\n");
+      break;
+    case fconst_0:
+      fprintf(stderr, "fconst_0\n");
+      break;
+    case fconst_1:
+      fprintf(stderr, "fconst_1\n");
+      break;
+    case fconst_2:
+      fprintf(stderr, "fconst_2\n");
+      break;
+    case fdiv:
+      fprintf(stderr, "fdiv\n");
+      break;
+    case fmul:
+      fprintf(stderr, "fmul\n");
+      break;
+    case fneg:
+      fprintf(stderr, "fneg\n");
+      break;
+    case frem:
+      fprintf(stderr, "frem\n");
+      break;
+    case fsub:
+      fprintf(stderr, "fsub\n");
+      break;
 
-      case bipush: fprintf(stderr, "bipush %02x\n", code[ip++]); break;
-      case caload: fprintf(stderr, "caload\n"); break;
-      case castore: fprintf(stderr, "castore\n"); break;
-      case checkcast: fprintf(stderr, "checkcast %04x\n", read16(code, ip)); break;
-      case d2f: fprintf(stderr, "d2f\n"); break;
-      case d2i: fprintf(stderr, "d2i\n"); break;
-      case d2l: fprintf(stderr, "d2l\n"); break;
-      case dadd: fprintf(stderr, "dadd\n"); break;
-      case daload: fprintf(stderr, "daload\n"); break;
-      case dastore: fprintf(stderr, "dastore\n"); break;
-      case dcmpg: fprintf(stderr, "dcmpg\n"); break;
-      case dcmpl: fprintf(stderr, "dcmpl\n"); break;
-      case dconst_0: fprintf(stderr, "dconst_0\n"); break;
-      case dconst_1: fprintf(stderr, "dconst_1\n"); break;
-      case ddiv: fprintf(stderr, "ddiv\n"); break;
-      case dmul: fprintf(stderr, "dmul\n"); break;
-      case dneg: fprintf(stderr, "dneg\n"); break;
-      case vm::drem: fprintf(stderr, "drem\n"); break;
-      case dsub: fprintf(stderr, "dsub\n"); break;
-      case vm::dup:
-        fprintf(stderr, "dup\n");
+    case getfield:
+      fprintf(stderr, "getfield %04x\n", read16(code, ip));
+      break;
+    case getstatic:
+      fprintf(stderr, "getstatic %04x\n", read16(code, ip));
+      break;
+    case goto_: {
+      int16_t offset = read16(code, ip);
+      fprintf(stderr, "goto %04x\n", offset + ip - 3);
+    } break;
+    case goto_w: {
+      int32_t offset = read32(code, ip);
+      fprintf(stderr, "goto_w %08x\n", offset + ip - 5);
+    } break;
+
+    case i2b:
+      fprintf(stderr, "i2b\n");
+      break;
+    case i2c:
+      fprintf(stderr, "i2c\n");
+      break;
+    case i2d:
+      fprintf(stderr, "i2d\n");
+      break;
+    case i2f:
+      fprintf(stderr, "i2f\n");
+      break;
+    case i2l:
+      fprintf(stderr, "i2l\n");
+      break;
+    case i2s:
+      fprintf(stderr, "i2s\n");
+      break;
+    case iadd:
+      fprintf(stderr, "iadd\n");
+      break;
+    case iaload:
+      fprintf(stderr, "iaload\n");
+      break;
+    case iand:
+      fprintf(stderr, "iand\n");
+      break;
+    case iastore:
+      fprintf(stderr, "iastore\n");
+      break;
+    case iconst_m1:
+      fprintf(stderr, "iconst_m1\n");
+      break;
+    case iconst_0:
+      fprintf(stderr, "iconst_0\n");
+      break;
+    case iconst_1:
+      fprintf(stderr, "iconst_1\n");
+      break;
+    case iconst_2:
+      fprintf(stderr, "iconst_2\n");
+      break;
+    case iconst_3:
+      fprintf(stderr, "iconst_3\n");
+      break;
+    case iconst_4:
+      fprintf(stderr, "iconst_4\n");
+      break;
+    case iconst_5:
+      fprintf(stderr, "iconst_5\n");
+      break;
+    case idiv:
+      fprintf(stderr, "idiv\n");
+      break;
+
+    case if_acmpeq: {
+      int16_t offset = read16(code, ip);
+      fprintf(stderr, "if_acmpeq %04x\n", offset + ip - 3);
+    } break;
+    case if_acmpne: {
+      int16_t offset = read16(code, ip);
+      fprintf(stderr, "if_acmpne %04x\n", offset + ip - 3);
+    } break;
+    case if_icmpeq: {
+      int16_t offset = read16(code, ip);
+      fprintf(stderr, "if_icmpeq %04x\n", offset + ip - 3);
+    } break;
+    case if_icmpne: {
+      int16_t offset = read16(code, ip);
+      fprintf(stderr, "if_icmpne %04x\n", offset + ip - 3);
+    } break;
+
+    case if_icmpgt: {
+      int16_t offset = read16(code, ip);
+      fprintf(stderr, "if_icmpgt %04x\n", offset + ip - 3);
+    } break;
+    case if_icmpge: {
+      int16_t offset = read16(code, ip);
+      fprintf(stderr, "if_icmpge %04x\n", offset + ip - 3);
+    } break;
+    case if_icmplt: {
+      int16_t offset = read16(code, ip);
+      fprintf(stderr, "if_icmplt %04x\n", offset + ip - 3);
+    } break;
+    case if_icmple: {
+      int16_t offset = read16(code, ip);
+      fprintf(stderr, "if_icmple %04x\n", offset + ip - 3);
+    } break;
+
+    case ifeq: {
+      int16_t offset = read16(code, ip);
+      fprintf(stderr, "ifeq %04x\n", offset + ip - 3);
+    } break;
+    case ifne: {
+      int16_t offset = read16(code, ip);
+      fprintf(stderr, "ifne %04x\n", offset + ip - 3);
+    } break;
+    case ifgt: {
+      int16_t offset = read16(code, ip);
+      fprintf(stderr, "ifgt %04x\n", offset + ip - 3);
+    } break;
+    case ifge: {
+      int16_t offset = read16(code, ip);
+      fprintf(stderr, "ifge %04x\n", offset + ip - 3);
+    } break;
+    case iflt: {
+      int16_t offset = read16(code, ip);
+      fprintf(stderr, "iflt %04x\n", offset + ip - 3);
+    } break;
+    case ifle: {
+      int16_t offset = read16(code, ip);
+      fprintf(stderr, "ifle %04x\n", offset + ip - 3);
+    } break;
+
+    case ifnonnull: {
+      int16_t offset = read16(code, ip);
+      fprintf(stderr, "ifnonnull %04x\n", offset + ip - 3);
+    } break;
+    case ifnull: {
+      int16_t offset = read16(code, ip);
+      fprintf(stderr, "ifnull %04x\n", offset + ip - 3);
+    } break;
+
+    case iinc: {
+      uint8_t a = code[ip++];
+      uint8_t b = code[ip++];
+      fprintf(stderr, "iinc %02x %02x\n", a, b);
+    } break;
+
+    case iload:
+      fprintf(stderr, "iload %02x\n", code[ip++]);
+      break;
+    case fload:
+      fprintf(stderr, "fload %02x\n", code[ip++]);
+      break;
+
+    case iload_0:
+      fprintf(stderr, "iload_0\n");
+      break;
+    case fload_0:
+      fprintf(stderr, "fload_0\n");
+      break;
+    case iload_1:
+      fprintf(stderr, "iload_1\n");
+      break;
+    case fload_1:
+      fprintf(stderr, "fload_1\n");
+      break;
+
+    case iload_2:
+      fprintf(stderr, "iload_2\n");
+      break;
+    case fload_2:
+      fprintf(stderr, "fload_2\n");
+      break;
+    case iload_3:
+      fprintf(stderr, "iload_3\n");
+      break;
+    case fload_3:
+      fprintf(stderr, "fload_3\n");
+      break;
+
+    case imul:
+      fprintf(stderr, "imul\n");
+      break;
+    case ineg:
+      fprintf(stderr, "ineg\n");
+      break;
+
+    case instanceof:
+      fprintf(stderr, "instanceof %04x\n", read16(code, ip));
+      break;
+    case invokeinterface:
+      fprintf(stderr, "invokeinterface %04x\n", read16(code, ip));
+      break;
+    case invokespecial:
+      fprintf(stderr, "invokespecial %04x\n", read16(code, ip));
+      break;
+    case invokestatic:
+      fprintf(stderr, "invokestatic %04x\n", read16(code, ip));
+      break;
+    case invokevirtual:
+      fprintf(stderr, "invokevirtual %04x\n", read16(code, ip));
+      break;
+
+    case ior:
+      fprintf(stderr, "ior\n");
+      break;
+    case irem:
+      fprintf(stderr, "irem\n");
+      break;
+    case ireturn:
+      fprintf(stderr, "ireturn\n");
+      break;
+    case freturn:
+      fprintf(stderr, "freturn\n");
+      break;
+    case ishl:
+      fprintf(stderr, "ishl\n");
+      break;
+    case ishr:
+      fprintf(stderr, "ishr\n");
+      break;
+
+    case istore:
+      fprintf(stderr, "istore %02x\n", code[ip++]);
+      break;
+    case fstore:
+      fprintf(stderr, "fstore %02x\n", code[ip++]);
+      break;
+
+    case istore_0:
+      fprintf(stderr, "istore_0\n");
+      break;
+    case fstore_0:
+      fprintf(stderr, "fstore_0\n");
+      break;
+    case istore_1:
+      fprintf(stderr, "istore_1\n");
+      break;
+    case fstore_1:
+      fprintf(stderr, "fstore_1\n");
+      break;
+    case istore_2:
+      fprintf(stderr, "istore_2\n");
+      break;
+    case fstore_2:
+      fprintf(stderr, "fstore_2\n");
+      break;
+    case istore_3:
+      fprintf(stderr, "istore_3\n");
+      break;
+    case fstore_3:
+      fprintf(stderr, "fstore_3\n");
+      break;
+
+    case isub:
+      fprintf(stderr, "isub\n");
+      break;
+    case iushr:
+      fprintf(stderr, "iushr\n");
+      break;
+    case ixor:
+      fprintf(stderr, "ixor\n");
+      break;
+
+    case jsr:
+      fprintf(stderr, "jsr %04x\n", read16(code, ip));
+      break;
+    case jsr_w:
+      fprintf(stderr, "jsr_w %08x\n", read32(code, ip));
+      break;
+
+    case l2d:
+      fprintf(stderr, "l2d\n");
+      break;
+    case l2f:
+      fprintf(stderr, "l2f\n");
+      break;
+    case l2i:
+      fprintf(stderr, "l2i\n");
+      break;
+    case ladd:
+      fprintf(stderr, "ladd\n");
+      break;
+    case laload:
+      fprintf(stderr, "laload\n");
+      break;
+
+    case land:
+      fprintf(stderr, "land\n");
+      break;
+    case lastore:
+      fprintf(stderr, "lastore\n");
+      break;
+
+    case lcmp:
+      fprintf(stderr, "lcmp\n");
+      break;
+    case lconst_0:
+      fprintf(stderr, "lconst_0\n");
+      break;
+    case lconst_1:
+      fprintf(stderr, "lconst_1\n");
+      break;
+
+    case ldc:
+      fprintf(stderr, "ldc %04x\n", read16(code, ip));
+      break;
+    case ldc_w:
+      fprintf(stderr, "ldc_w %08x\n", read32(code, ip));
+      break;
+    case ldc2_w:
+      fprintf(stderr, "ldc2_w %04x\n", read16(code, ip));
+      break;
+
+    case ldiv_:
+      fprintf(stderr, "ldiv_\n");
+      break;
+
+    case lload:
+      fprintf(stderr, "lload %02x\n", code[ip++]);
+      break;
+    case dload:
+      fprintf(stderr, "dload %02x\n", code[ip++]);
+      break;
+
+    case lload_0:
+      fprintf(stderr, "lload_0\n");
+      break;
+    case dload_0:
+      fprintf(stderr, "dload_0\n");
+      break;
+    case lload_1:
+      fprintf(stderr, "lload_1\n");
+      break;
+    case dload_1:
+      fprintf(stderr, "dload_1\n");
+      break;
+    case lload_2:
+      fprintf(stderr, "lload_2\n");
+      break;
+    case dload_2:
+      fprintf(stderr, "dload_2\n");
+      break;
+    case lload_3:
+      fprintf(stderr, "lload_3\n");
+      break;
+    case dload_3:
+      fprintf(stderr, "dload_3\n");
+      break;
+
+    case lmul:
+      fprintf(stderr, "lmul\n");
+      break;
+    case lneg:
+      fprintf(stderr, "lneg\n");
+      break;
+
+    case lookupswitch: {
+      int32_t default_ = read32(code, ip);
+      int32_t pairCount = read32(code, ip);
+      fprintf(stderr,
+              "lookupswitch default: %d pairCount: %d\n",
+              default_,
+              pairCount);
+
+      for (int i = 0; i < pairCount; i++) {
+        int32_t k = read32(code, ip);
+        int32_t d = read32(code, ip);
+        fprintf(stderr, "%s  key: %02x dest: %2x\n", prefix, k, d);
+      }
+    } break;
+
+    case lor:
+      fprintf(stderr, "lor\n");
+      break;
+    case lrem:
+      fprintf(stderr, "lrem\n");
+      break;
+    case lreturn:
+      fprintf(stderr, "lreturn\n");
+      break;
+    case dreturn:
+      fprintf(stderr, "dreturn\n");
+      break;
+    case lshl:
+      fprintf(stderr, "lshl\n");
+      break;
+    case lshr:
+      fprintf(stderr, "lshr\n");
+      break;
+
+    case lstore:
+      fprintf(stderr, "lstore %02x\n", code[ip++]);
+      break;
+    case dstore:
+      fprintf(stderr, "dstore %02x\n", code[ip++]);
+      break;
+
+    case lstore_0:
+      fprintf(stderr, "lstore_0\n");
+      break;
+    case dstore_0:
+      fprintf(stderr, "dstore_0\n");
+      break;
+    case lstore_1:
+      fprintf(stderr, "lstore_1\n");
+      break;
+    case dstore_1:
+      fprintf(stderr, "dstore_1\n");
+      break;
+    case lstore_2:
+      fprintf(stderr, "lstore_2\n");
+      break;
+    case dstore_2:
+      fprintf(stderr, "dstore_2\n");
+      break;
+    case lstore_3:
+      fprintf(stderr, "lstore_3\n");
+      break;
+    case dstore_3:
+      fprintf(stderr, "dstore_3\n");
+      break;
+
+    case lsub:
+      fprintf(stderr, "lsub\n");
+      break;
+    case lushr:
+      fprintf(stderr, "lushr\n");
+      break;
+    case lxor:
+      fprintf(stderr, "lxor\n");
+      break;
+
+    case monitorenter:
+      fprintf(stderr, "monitorenter\n");
+      break;
+    case monitorexit:
+      fprintf(stderr, "monitorexit\n");
+      break;
+
+    case multianewarray: {
+      unsigned type = read16(code, ip);
+      fprintf(stderr, "multianewarray %04x %02x\n", type, code[ip++]);
+    } break;
+
+    case new_:
+      fprintf(stderr, "new %04x\n", read16(code, ip));
+      break;
+
+    case newarray:
+      fprintf(stderr, "newarray %02x\n", code[ip++]);
+      break;
+
+    case nop:
+      fprintf(stderr, "nop\n");
+      break;
+    case pop_:
+      fprintf(stderr, "pop\n");
+      break;
+    case pop2:
+      fprintf(stderr, "pop2\n");
+      break;
+
+    case putfield:
+      fprintf(stderr, "putfield %04x\n", read16(code, ip));
+      break;
+    case putstatic:
+      fprintf(stderr, "putstatic %04x\n", read16(code, ip));
+      break;
+
+    case ret:
+      fprintf(stderr, "ret %02x\n", code[ip++]);
+      break;
+
+    case return_:
+      fprintf(stderr, "return_\n");
+      break;
+    case saload:
+      fprintf(stderr, "saload\n");
+      break;
+    case sastore:
+      fprintf(stderr, "sastore\n");
+      break;
+
+    case sipush:
+      fprintf(stderr, "sipush %04x\n", read16(code, ip));
+      break;
+
+    case swap:
+      fprintf(stderr, "swap\n");
+      break;
+
+    case tableswitch: {
+      int32_t default_ = read32(code, ip);
+      int32_t bottom = read32(code, ip);
+      int32_t top = read32(code, ip);
+      fprintf(stderr,
+              "tableswitch default: %d bottom: %d top: %d\n",
+              default_,
+              bottom,
+              top);
+
+      for (int i = 0; i < top - bottom + 1; i++) {
+        int32_t d = read32(code, ip);
+        fprintf(stderr, "%s  key: %d dest: %2x\n", prefix, i + bottom, d);
+      }
+    } break;
+
+    case wide: {
+      switch (code[ip++]) {
+      case aload:
+        fprintf(stderr, "wide aload %04x\n", read16(code, ip));
         break;
-      case dup_x1: fprintf(stderr, "dup_x1\n"); break;
-      case dup_x2: fprintf(stderr, "dup_x2\n"); break;
-      case vm::dup2:
-        fprintf(stderr, "dup2\n");
+
+      case astore:
+        fprintf(stderr, "wide astore %04x\n", read16(code, ip));
+        break;
+      case iinc:
+        fprintf(stderr,
+                "wide iinc %04x %04x\n",
+                read16(code, ip),
+                read16(code, ip));
+        break;
+      case iload:
+        fprintf(stderr, "wide iload %04x\n", read16(code, ip));
+        break;
+      case istore:
+        fprintf(stderr, "wide istore %04x\n", read16(code, ip));
+        break;
+      case lload:
+        fprintf(stderr, "wide lload %04x\n", read16(code, ip));
+        break;
+      case lstore:
+        fprintf(stderr, "wide lstore %04x\n", read16(code, ip));
+        break;
+      case ret:
+        fprintf(stderr, "wide ret %04x\n", read16(code, ip));
         break;
-      case dup2_x1: fprintf(stderr, "dup2_x1\n"); break;
-      case dup2_x2: fprintf(stderr, "dup2_x2\n"); break;
-      case f2d: fprintf(stderr, "f2d\n"); break;
-      case f2i: fprintf(stderr, "f2i\n"); break;
-      case f2l: fprintf(stderr, "f2l\n"); break;
-      case fadd: fprintf(stderr, "fadd\n"); break;
-      case faload: fprintf(stderr, "faload\n"); break;
-      case fastore: fprintf(stderr, "fastore\n"); break;
-      case fcmpg: fprintf(stderr, "fcmpg\n"); break;
-      case fcmpl: fprintf(stderr, "fcmpl\n"); break;
-      case fconst_0: fprintf(stderr, "fconst_0\n"); break;
-      case fconst_1: fprintf(stderr, "fconst_1\n"); break;
-      case fconst_2: fprintf(stderr, "fconst_2\n"); break;
-      case fdiv: fprintf(stderr, "fdiv\n"); break;
-      case fmul: fprintf(stderr, "fmul\n"); break;
-      case fneg: fprintf(stderr, "fneg\n"); break;
-      case frem: fprintf(stderr, "frem\n"); break;
-      case fsub: fprintf(stderr, "fsub\n"); break;
-
-      case getfield: fprintf(stderr, "getfield %04x\n", read16(code, ip)); break;
-      case getstatic: fprintf(stderr, "getstatic %04x\n", read16(code, ip)); break;
-      case goto_: {
-        int16_t offset = read16(code, ip);
-        fprintf(stderr, "goto %04x\n", offset + ip - 3);
-      } break;
-      case goto_w: {
-        int32_t offset = read32(code, ip);
-        fprintf(stderr, "goto_w %08x\n", offset + ip - 5);
-      } break;
-
-      case i2b: fprintf(stderr, "i2b\n"); break;
-      case i2c: fprintf(stderr, "i2c\n"); break;
-      case i2d: fprintf(stderr, "i2d\n"); break;
-      case i2f: fprintf(stderr, "i2f\n"); break;
-      case i2l: fprintf(stderr, "i2l\n"); break;
-      case i2s: fprintf(stderr, "i2s\n"); break;
-      case iadd: fprintf(stderr, "iadd\n"); break;
-      case iaload: fprintf(stderr, "iaload\n"); break;
-      case iand: fprintf(stderr, "iand\n"); break;
-      case iastore: fprintf(stderr, "iastore\n"); break;
-      case iconst_m1: fprintf(stderr, "iconst_m1\n"); break;
-      case iconst_0: fprintf(stderr, "iconst_0\n"); break;
-      case iconst_1: fprintf(stderr, "iconst_1\n"); break;
-      case iconst_2: fprintf(stderr, "iconst_2\n"); break;
-      case iconst_3: fprintf(stderr, "iconst_3\n"); break;
-      case iconst_4: fprintf(stderr, "iconst_4\n"); break;
-      case iconst_5: fprintf(stderr, "iconst_5\n"); break;
-      case idiv: fprintf(stderr, "idiv\n"); break;
-
-      case if_acmpeq: {
-        int16_t offset = read16(code, ip);
-        fprintf(stderr, "if_acmpeq %04x\n", offset + ip - 3);
-      } break;
-      case if_acmpne: {
-        int16_t offset = read16(code, ip);
-        fprintf(stderr, "if_acmpne %04x\n", offset + ip - 3);
-      } break;
-      case if_icmpeq: {
-        int16_t offset = read16(code, ip);
-        fprintf(stderr, "if_icmpeq %04x\n", offset + ip - 3);
-      } break;
-      case if_icmpne: {
-        int16_t offset = read16(code, ip);
-        fprintf(stderr, "if_icmpne %04x\n", offset + ip - 3);
-      } break;
-
-      case if_icmpgt: {
-        int16_t offset = read16(code, ip);
-        fprintf(stderr, "if_icmpgt %04x\n", offset + ip - 3);
-      } break;
-      case if_icmpge: {
-        int16_t offset = read16(code, ip);
-        fprintf(stderr, "if_icmpge %04x\n", offset + ip - 3);
-      } break;
-      case if_icmplt: {
-        int16_t offset = read16(code, ip);
-        fprintf(stderr, "if_icmplt %04x\n", offset + ip - 3);
-      } break;
-      case if_icmple: {
-        int16_t offset = read16(code, ip);
-        fprintf(stderr, "if_icmple %04x\n", offset + ip - 3);
-      } break;
-
-      case ifeq: {
-        int16_t offset = read16(code, ip);
-        fprintf(stderr, "ifeq %04x\n", offset + ip - 3);
-      } break;
-      case ifne: {
-        int16_t offset = read16(code, ip);
-        fprintf(stderr, "ifne %04x\n", offset + ip - 3);
-      } break;
-      case ifgt: {
-        int16_t offset = read16(code, ip);
-        fprintf(stderr, "ifgt %04x\n", offset + ip - 3);
-      } break;
-      case ifge: {
-        int16_t offset = read16(code, ip);
-        fprintf(stderr, "ifge %04x\n", offset + ip - 3);
-      } break;
-      case iflt: {
-        int16_t offset = read16(code, ip);
-        fprintf(stderr, "iflt %04x\n", offset + ip - 3);
-      } break;
-      case ifle: {
-        int16_t offset = read16(code, ip);
-        fprintf(stderr, "ifle %04x\n", offset + ip - 3);
-      } break;
-
-      case ifnonnull: {
-        int16_t offset = read16(code, ip);
-        fprintf(stderr, "ifnonnull %04x\n", offset + ip - 3);
-      } break;
-      case ifnull: {
-        int16_t offset = read16(code, ip);
-        fprintf(stderr, "ifnull %04x\n", offset + ip - 3);
-      } break;
-
-      case iinc: {
-        uint8_t a = code[ip++];
-        uint8_t b = code[ip++];
-        fprintf(stderr, "iinc %02x %02x\n", a, b);
-      } break;
-
-      case iload: fprintf(stderr, "iload %02x\n", code[ip++]); break;
-      case fload: fprintf(stderr, "fload %02x\n", code[ip++]); break;
-
-      case iload_0: fprintf(stderr, "iload_0\n"); break;
-      case fload_0: fprintf(stderr, "fload_0\n"); break;
-      case iload_1: fprintf(stderr, "iload_1\n"); break;
-      case fload_1: fprintf(stderr, "fload_1\n"); break;
-
-      case iload_2: fprintf(stderr, "iload_2\n"); break;
-      case fload_2: fprintf(stderr, "fload_2\n"); break;
-      case iload_3: fprintf(stderr, "iload_3\n"); break;
-      case fload_3: fprintf(stderr, "fload_3\n"); break;
-
-      case imul: fprintf(stderr, "imul\n"); break;
-      case ineg: fprintf(stderr, "ineg\n"); break;
-
-      case instanceof: fprintf(stderr, "instanceof %04x\n", read16(code, ip)); break;
-      case invokeinterface: fprintf(stderr, "invokeinterface %04x\n", read16(code, ip)); break;
-      case invokespecial: fprintf(stderr, "invokespecial %04x\n", read16(code, ip)); break;
-      case invokestatic: fprintf(stderr, "invokestatic %04x\n", read16(code, ip)); break;
-      case invokevirtual: fprintf(stderr, "invokevirtual %04x\n", read16(code, ip)); break;
-
-      case ior: fprintf(stderr, "ior\n"); break;
-      case irem: fprintf(stderr, "irem\n"); break;
-      case ireturn: fprintf(stderr, "ireturn\n"); break;
-      case freturn: fprintf(stderr, "freturn\n"); break;
-      case ishl: fprintf(stderr, "ishl\n"); break;
-      case ishr: fprintf(stderr, "ishr\n"); break;
-
-      case istore: fprintf(stderr, "istore %02x\n", code[ip++]); break;
-      case fstore: fprintf(stderr, "fstore %02x\n", code[ip++]); break;
-
-      case istore_0: fprintf(stderr, "istore_0\n"); break;
-      case fstore_0: fprintf(stderr, "fstore_0\n"); break;
-      case istore_1: fprintf(stderr, "istore_1\n"); break;
-      case fstore_1: fprintf(stderr, "fstore_1\n"); break;
-      case istore_2: fprintf(stderr, "istore_2\n"); break;
-      case fstore_2: fprintf(stderr, "fstore_2\n"); break;
-      case istore_3: fprintf(stderr, "istore_3\n"); break;
-      case fstore_3: fprintf(stderr, "fstore_3\n"); break;
-
-      case isub: fprintf(stderr, "isub\n"); break;
-      case iushr: fprintf(stderr, "iushr\n"); break;
-      case ixor: fprintf(stderr, "ixor\n"); break;
-
-      case jsr: fprintf(stderr, "jsr %04x\n", read16(code, ip)); break;
-      case jsr_w: fprintf(stderr, "jsr_w %08x\n", read32(code, ip)); break;
-
-      case l2d: fprintf(stderr, "l2d\n"); break;
-      case l2f: fprintf(stderr, "l2f\n"); break;
-      case l2i: fprintf(stderr, "l2i\n"); break;
-      case ladd: fprintf(stderr, "ladd\n"); break;
-      case laload: fprintf(stderr, "laload\n"); break;
-
-      case land: fprintf(stderr, "land\n"); break;
-      case lastore: fprintf(stderr, "lastore\n"); break;
-
-      case lcmp: fprintf(stderr, "lcmp\n"); break;
-      case lconst_0: fprintf(stderr, "lconst_0\n"); break;
-      case lconst_1: fprintf(stderr, "lconst_1\n"); break;
-
-      case ldc: fprintf(stderr, "ldc %04x\n", read16(code, ip)); break;
-      case ldc_w: fprintf(stderr, "ldc_w %08x\n", read32(code, ip)); break;
-      case ldc2_w: fprintf(stderr, "ldc2_w %04x\n", read16(code, ip)); break;
-
-      case ldiv_: fprintf(stderr, "ldiv_\n"); break;
-
-      case lload: fprintf(stderr, "lload %02x\n", code[ip++]); break;
-      case dload: fprintf(stderr, "dload %02x\n", code[ip++]); break;
-
-      case lload_0: fprintf(stderr, "lload_0\n"); break;
-      case dload_0: fprintf(stderr, "dload_0\n"); break;
-      case lload_1: fprintf(stderr, "lload_1\n"); break;
-      case dload_1: fprintf(stderr, "dload_1\n"); break;
-      case lload_2: fprintf(stderr, "lload_2\n"); break;
-      case dload_2: fprintf(stderr, "dload_2\n"); break;
-      case lload_3: fprintf(stderr, "lload_3\n"); break;
-      case dload_3: fprintf(stderr, "dload_3\n"); break;
-
-      case lmul: fprintf(stderr, "lmul\n"); break;
-      case lneg: fprintf(stderr, "lneg\n"); break;
-
-      case lookupswitch: {
-        int32_t default_ = read32(code, ip);
-        int32_t pairCount = read32(code, ip);
-        fprintf(stderr, "lookupswitch default: %d pairCount: %d\n", default_, pairCount);
-
-        for (int i = 0; i < pairCount; i++) {
-          int32_t k = read32(code, ip);
-          int32_t d = read32(code, ip);
-          fprintf(stderr, "%s  key: %02x dest: %2x\n", prefix, k, d);
-        }
-      } break;
-
-      case lor: fprintf(stderr, "lor\n"); break;
-      case lrem: fprintf(stderr, "lrem\n"); break;
-      case lreturn: fprintf(stderr, "lreturn\n"); break;
-      case dreturn: fprintf(stderr, "dreturn\n"); break;
-      case lshl: fprintf(stderr, "lshl\n"); break;
-      case lshr: fprintf(stderr, "lshr\n"); break;
-
-      case lstore: fprintf(stderr, "lstore %02x\n", code[ip++]); break;
-      case dstore: fprintf(stderr, "dstore %02x\n", code[ip++]); break;
-
-      case lstore_0: fprintf(stderr, "lstore_0\n"); break;
-      case dstore_0: fprintf(stderr, "dstore_0\n"); break;
-      case lstore_1: fprintf(stderr, "lstore_1\n"); break;
-      case dstore_1: fprintf(stderr, "dstore_1\n"); break;
-      case lstore_2: fprintf(stderr, "lstore_2\n"); break;
-      case dstore_2: fprintf(stderr, "dstore_2\n"); break;
-      case lstore_3: fprintf(stderr, "lstore_3\n"); break;
-      case dstore_3: fprintf(stderr, "dstore_3\n"); break;
-
-      case lsub: fprintf(stderr, "lsub\n"); break;
-      case lushr: fprintf(stderr, "lushr\n"); break;
-      case lxor: fprintf(stderr, "lxor\n"); break;
-
-      case monitorenter: fprintf(stderr, "monitorenter\n"); break;
-      case monitorexit: fprintf(stderr, "monitorexit\n"); break;
-
-      case multianewarray: {
-        unsigned type = read16(code, ip);
-        fprintf(stderr, "multianewarray %04x %02x\n", type, code[ip++]);
-      } break;
-
-      case new_: fprintf(stderr, "new %04x\n", read16(code, ip)); break;
-
-      case newarray: fprintf(stderr, "newarray %02x\n", code[ip++]); break;
-
-      case nop: fprintf(stderr, "nop\n"); break;
-      case pop_: fprintf(stderr, "pop\n"); break;
-      case pop2: fprintf(stderr, "pop2\n"); break;
-
-      case putfield: fprintf(stderr, "putfield %04x\n", read16(code, ip)); break;
-      case putstatic: fprintf(stderr, "putstatic %04x\n", read16(code, ip)); break;
-
-      case ret: fprintf(stderr, "ret %02x\n", code[ip++]); break;
-
-      case return_: fprintf(stderr, "return_\n"); break;
-      case saload: fprintf(stderr, "saload\n"); break;
-      case sastore: fprintf(stderr, "sastore\n"); break;
-
-      case sipush: fprintf(stderr, "sipush %04x\n", read16(code, ip)); break;
-
-      case swap: fprintf(stderr, "swap\n"); break;
-
-      case tableswitch: {
-        int32_t default_ = read32(code, ip);
-        int32_t bottom = read32(code, ip);
-        int32_t top = read32(code, ip);
-        fprintf(stderr, "tableswitch default: %d bottom: %d top: %d\n", default_, bottom, top);
-
-        for (int i = 0; i < top - bottom + 1; i++) {
-          int32_t d = read32(code, ip);
-          fprintf(stderr, "%s  key: %d dest: %2x\n", prefix, i + bottom, d);
-        }
-      } break;
-
-      case wide: {
-        switch (code[ip++]) {
-          case aload: fprintf(stderr, "wide aload %04x\n", read16(code, ip)); break;
-
-          case astore: fprintf(stderr, "wide astore %04x\n", read16(code, ip)); break;
-          case iinc: fprintf(stderr, "wide iinc %04x %04x\n", read16(code, ip), read16(code, ip)); break;
-          case iload: fprintf(stderr, "wide iload %04x\n", read16(code, ip)); break;
-          case istore: fprintf(stderr, "wide istore %04x\n", read16(code, ip)); break;
-          case lload: fprintf(stderr, "wide lload %04x\n", read16(code, ip)); break;
-          case lstore: fprintf(stderr, "wide lstore %04x\n", read16(code, ip)); break;
-          case ret: fprintf(stderr, "wide ret %04x\n", read16(code, ip)); break;
-
-          default: {
-            fprintf(stderr, "unknown wide instruction %02x %04x\n", instr, read16(code, ip));
-          }
-        }
-      } break;
 
       default: {
-        fprintf(stderr, "unknown instruction %02x\n", instr);
+        fprintf(stderr,
+                "unknown wide instruction %02x %04x\n",
+                instr,
+                read16(code, ip));
       }
+      }
+    } break;
+
+    default: {
+      fprintf(stderr, "unknown instruction %02x\n", instr);
+    }
     }
   }
 }
@@ -1895,15 +2286,19 @@ GcCode* parseCode(Thread* t, Stream& s, GcSingleton* pool)
   unsigned maxLocals = s.read2();
   unsigned length = s.read4();
 
-  if(DebugClassReader) {
-    fprintf(stderr, "    code: maxStack %d maxLocals %d length %d\n", maxStack, maxLocals, length);
+  if (DebugClassReader) {
+    fprintf(stderr,
+            "    code: maxStack %d maxLocals %d length %d\n",
+            maxStack,
+            maxLocals,
+            length);
   }
 
   GcCode* code = makeCode(t, pool, 0, 0, 0, 0, 0, maxStack, maxLocals, length);
   s.read(code->body().begin(), length);
   PROTECT(t, code);
 
-  if(DebugClassReader) {
+  if (DebugClassReader) {
     disassembleCode("      ", code->body().begin(), length);
   }
 
@@ -2041,10 +2436,10 @@ void parseMethodTable(Thread* t, Stream& s, GcClass* class_, GcSingleton* pool)
 
   GcList* newVirtuals = makeList(t, 0, 0, 0);
   PROTECT(t, newVirtuals);
-  
+
   unsigned count = s.read2();
 
-  if(DebugClassReader) {
+  if (DebugClassReader) {
     fprintf(stderr, "  method count %d\n", count);
   }
 
@@ -2063,7 +2458,7 @@ void parseMethodTable(Thread* t, Stream& s, GcClass* class_, GcSingleton* pool)
       unsigned name = s.read2();
       unsigned spec = s.read2();
 
-      if(DebugClassReader) {
+      if (DebugClassReader) {
         fprintf(stderr,
                 "    method flags %d name %d spec %d '%s%s'\n",
                 flags,
@@ -2153,8 +2548,12 @@ void parseMethodTable(Thread* t, Stream& s, GcClass* class_, GcSingleton* pool)
       unsigned parameterCount;
       unsigned parameterFootprint;
       unsigned returnCode;
-      scanMethodSpec(t, specString, flags & ACC_STATIC, &parameterCount,
-                     &parameterFootprint, &returnCode);
+      scanMethodSpec(t,
+                     specString,
+                     flags & ACC_STATIC,
+                     &parameterCount,
+                     &parameterFootprint,
+                     &returnCode);
 
       GcMethod* method = t->m->processor->makeMethod(
           t,
@@ -2173,7 +2572,7 @@ void parseMethodTable(Thread* t, Stream& s, GcClass* class_, GcSingleton* pool)
       PROTECT(t, method);
 
       if (methodVirtual(t, method)) {
-        ++ declaredVirtualCount;
+        ++declaredVirtualCount;
 
         GcTriple* p
             = hashMapFindNode(t, virtualMap, method, methodHash, methodEqual);
@@ -2258,7 +2657,7 @@ void parseMethodTable(Thread* t, Stream& s, GcClass* class_, GcSingleton* pool)
         GcMethod* method = cast<GcMethod>(t, it.next()->first());
         assertT(t, vtable->body()[method->offset()] == 0);
         vtable->setBodyElement(t, method->offset(), method);
-        ++ i;
+        ++i;
       }
     } else {
       populateInterfaceVtables = true;
@@ -2275,7 +2674,7 @@ void parseMethodTable(Thread* t, Stream& s, GcClass* class_, GcSingleton* pool)
       for (GcPair* p = cast<GcPair>(t, newVirtuals->front()); p;
            p = cast<GcPair>(t, p->second())) {
         vtable->setBodyElement(t, i, p->first());
-        ++ i;
+        ++i;
       }
     }
 
@@ -2339,8 +2738,8 @@ void parseMethodTable(Thread* t, Stream& s, GcClass* class_, GcSingleton* pool)
 
           for (unsigned j = 0; j < ivtable->length(); ++j) {
             object method = ivtable->body()[j];
-            method = hashMapFind
-              (t, virtualMap, method, methodHash, methodEqual);
+            method
+                = hashMapFind(t, virtualMap, method, methodHash, methodEqual);
             assertT(t, method);
 
             vtable->setBodyElement(t, j, method);
@@ -2576,17 +2975,19 @@ GcClass* makeArrayClass(Thread* t,
   const char* s = reinterpret_cast<const char*>(spec->body().begin());
   const char* start = s;
   unsigned dimensions = 0;
-  for (; *s == '['; ++s) ++ dimensions;
+  for (; *s == '['; ++s)
+    ++dimensions;
 
   GcByteArray* elementSpec;
   switch (*s) {
   case 'L': {
-    ++ s;
+    ++s;
     const char* elementSpecStart = s;
-    while (*s and *s != ';') ++ s;
+    while (*s and *s != ';')
+      ++s;
     if (dimensions > 1) {
       elementSpecStart -= dimensions;
-      ++ s;
+      ++s;
     }
 
     elementSpec = makeByteArray(t, s - elementSpecStart + 1);
@@ -2606,7 +3007,7 @@ GcClass* makeArrayClass(Thread* t,
       }
       elementSpec->body()[i++] = c;
       elementSpec->body()[i] = 0;
-      -- dimensions;
+      --dimensions;
     } else {
       abort(t);
     }
@@ -2622,7 +3023,8 @@ GcClass* makeArrayClass(Thread* t,
 
   if (elementClass == 0) {
     elementClass = resolveClass(t, loader, elementSpec, throw_, throwType);
-    if (elementClass == 0) return 0;
+    if (elementClass == 0)
+      return 0;
   }
 
   PROTECT(t, elementClass);
@@ -2675,8 +3077,7 @@ GcClass* resolveArrayClass(Thread* t,
   }
 }
 
-void
-removeMonitor(Thread* t, object o)
+void removeMonitor(Thread* t, object o)
 {
   unsigned hash;
   if (DebugMonitors) {
@@ -2691,8 +3092,7 @@ removeMonitor(Thread* t, object o)
   }
 }
 
-void
-removeString(Thread* t, object o)
+void removeString(Thread* t, object o)
 {
   hashMapRemove(t, roots(t)->stringMap(), o, stringHash, objectEqual);
 }
@@ -2767,7 +3167,7 @@ void bootJavaClass(Thread* t,
   GcArray* vtable;
   if (vtableLength >= 0) {
     vtable = makeArray(t, vtableLength);
-    for (int i = 0; i < vtableLength; ++ i) {
+    for (int i = 0; i < vtableLength; ++i) {
       vtable->setBodyElement(t, i, bootMethod);
     }
   } else {
@@ -2788,8 +3188,7 @@ void nameClass(Thread* t, Gc::Type type, const char* name)
   cast<GcClass>(t, t->m->types->body()[type])->setName(t, n);
 }
 
-void
-makeArrayInterfaceTable(Thread* t)
+void makeArrayInterfaceTable(Thread* t)
 {
   GcArray* interfaceTable = makeArray(t, 4);
 
@@ -2800,8 +3199,7 @@ makeArrayInterfaceTable(Thread* t)
   roots(t)->setArrayInterfaceTable(t, interfaceTable);
 }
 
-void
-boot(Thread* t)
+void boot(Thread* t)
 {
   Machine* m = t->m;
 
@@ -2930,37 +3328,43 @@ boot(Thread* t)
   {
     GcCode* bootCode = makeCode(t, 0, 0, 0, 0, 0, 0, 0, 0, 1);
     bootCode->body()[0] = impdep1;
-    object bootMethod = makeMethod
-      (t, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, bootCode);
+    object bootMethod
+        = makeMethod(t, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, bootCode);
     PROTECT(t, bootMethod);
 
 #include "type-java-initializations.cpp"
 
-    //#ifdef AVIAN_HEAPDUMP
-#  include "type-name-initializations.cpp"
-      //#endif
+//#ifdef AVIAN_HEAPDUMP
+#include "type-name-initializations.cpp"
+    //#endif
   }
 }
 
-class HeapClient: public Heap::Client {
+class HeapClient : public Heap::Client {
  public:
-  HeapClient(Machine* m): m(m) { }
+  HeapClient(Machine* m) : m(m)
+  {
+  }
 
-  virtual void visitRoots(Heap::Visitor* v) {
+  virtual void visitRoots(Heap::Visitor* v)
+  {
     ::visitRoots(m, v);
 
     postVisit(m->rootThread, v);
   }
 
-  virtual void collect(void* context, Heap::CollectionType type) {
+  virtual void collect(void* context, Heap::CollectionType type)
+  {
     collect(static_cast<Thread*>(context), type);
   }
 
-  virtual bool isFixed(void* p) {
+  virtual bool isFixed(void* p)
+  {
     return objectFixed(m->rootThread, static_cast<object>(p));
   }
 
-  virtual unsigned sizeInWords(void* p) {
+  virtual unsigned sizeInWords(void* p)
+  {
     Thread* t = m->rootThread;
 
     object o = static_cast<object>(m->heap->follow(maskAlignedPointer(p)));
@@ -2968,13 +3372,14 @@ class HeapClient: public Heap::Client {
     unsigned n = baseSize(t, o, m->heap->follow(objectClass(t, o)));
 
     if (objectExtended(t, o)) {
-      ++ n;
+      ++n;
     }
 
     return n;
   }
 
-  virtual unsigned copiedSizeInWords(void* p) {
+  virtual unsigned copiedSizeInWords(void* p)
+  {
     Thread* t = m->rootThread;
 
     object o = static_cast<object>(m->heap->follow(maskAlignedPointer(p)));
@@ -2983,13 +3388,14 @@ class HeapClient: public Heap::Client {
     unsigned n = baseSize(t, o, m->heap->follow(objectClass(t, o)));
 
     if (objectExtended(t, o) or hashTaken(t, o)) {
-      ++ n;
+      ++n;
     }
 
     return n;
   }
 
-  virtual void copy(void* srcp, void* dstp) {
+  virtual void copy(void* srcp, void* dstp)
+  {
     Thread* t = m->rootThread;
 
     object src = static_cast<object>(m->heap->follow(maskAlignedPointer(srcp)));
@@ -3011,21 +3417,22 @@ class HeapClient: public Heap::Client {
     }
   }
 
-  virtual void walk(void* p, Heap::Walker* w) {
+  virtual void walk(void* p, Heap::Walker* w)
+  {
     object o = static_cast<object>(m->heap->follow(maskAlignedPointer(p)));
     ::walk(m->rootThread, w, o, 0);
   }
 
-  void dispose() {
+  void dispose()
+  {
     m->heap->free(this, sizeof(*this));
   }
-    
+
  private:
   Machine* m;
 };
 
-void
-doCollect(Thread* t, Heap::CollectionType type, int pendingAllocation)
+void doCollect(Thread* t, Heap::CollectionType type, int pendingAllocation)
 {
   expect(t, not t->m->collecting);
 
@@ -3034,14 +3441,17 @@ doCollect(Thread* t, Heap::CollectionType type, int pendingAllocation)
 
 #ifdef VM_STRESS
   bool stress = (t->flags & Thread::StressFlag) != 0;
-  if (not stress) atomicOr(&(t->flags), Thread::StressFlag);
+  if (not stress)
+    atomicOr(&(t->flags), Thread::StressFlag);
 #endif
 
   Machine* m = t->m;
 
   m->unsafe = true;
-  m->heap->collect(type, footprint(m->rootThread), pendingAllocation
-                   - (t->m->heapPoolIndex * ThreadHeapSizeInWords));
+  m->heap->collect(
+      type,
+      footprint(m->rootThread),
+      pendingAllocation - (t->m->heapPoolIndex * ThreadHeapSizeInWords));
   m->unsafe = false;
 
   postCollect(m->rootThread);
@@ -3062,7 +3472,8 @@ doCollect(Thread* t, Heap::CollectionType type, int pendingAllocation)
   }
 
 #ifdef VM_STRESS
-  if (not stress) atomicAnd(&(t->flags), ~Thread::StressFlag);
+  if (not stress)
+    atomicAnd(&(t->flags), ~Thread::StressFlag);
 #endif
 
   GcFinalizer* finalizeQueue = t->m->finalizeQueue;
@@ -3088,15 +3499,14 @@ doCollect(Thread* t, Heap::CollectionType type, int pendingAllocation)
   }
 }
 
-uint64_t
-invokeLoadClass(Thread* t, uintptr_t* arguments)
+uint64_t invokeLoadClass(Thread* t, uintptr_t* arguments)
 {
   GcMethod* method = cast<GcMethod>(t, reinterpret_cast<object>(arguments[0]));
   object loader = reinterpret_cast<object>(arguments[1]);
   object specString = reinterpret_cast<object>(arguments[2]);
 
-  return reinterpret_cast<uintptr_t>
-    (t->m->processor->invoke(t, method, loader, specString));
+  return reinterpret_cast<uintptr_t>(
+      t->m->processor->invoke(t, method, loader, specString));
 }
 
 bool isInitializing(Thread* t, GcClass* c)
@@ -3126,16 +3536,16 @@ object findInTable(Thread* t,
       }
     }
 
-//     fprintf(stderr, "%s %s not in\n",
+    //     fprintf(stderr, "%s %s not in\n",
     //             name->body().begin(),
     //             spec->body().begin();
 
-//     for (unsigned i = 0; i < arrayLength(t, table); ++i) {
-//       object o = arrayBody(t, table, i); 
-//       fprintf(stderr, "\t%s %s\n",
-//               &byteArrayBody(t, getName(t, o), 0),
-//               &byteArrayBody(t, getSpec(t, o), 0)); 
-//     }
+    //     for (unsigned i = 0; i < arrayLength(t, table); ++i) {
+    //       object o = arrayBody(t, table, i);
+    //       fprintf(stderr, "\t%s %s\n",
+    //               &byteArrayBody(t, getName(t, o), 0),
+    //               &byteArrayBody(t, getSpec(t, o), 0));
+    //     }
   }
 
   return 0;
@@ -3192,59 +3602,64 @@ void updatePackageMap(Thread* t, GcClass* class_)
   }
 }
 
-} // namespace
+}  // namespace
 
 namespace vm {
 
-Machine::Machine(System* system, Heap* heap, Finder* bootFinder,
-                 Finder* appFinder, Processor* processor, Classpath* classpath,
-                 const char** properties, unsigned propertyCount,
-                 const char** arguments, unsigned argumentCount,
-                 unsigned stackSizeInBytes):
-  vtable(&javaVMVTable),
-  system(system),
-  heapClient(new (heap->allocate(sizeof(HeapClient)))
-             HeapClient(this)),
-  heap(heap),
-  bootFinder(bootFinder),
-  appFinder(appFinder),
-  processor(processor),
-  classpath(classpath),
-  rootThread(0),
-  exclusive(0),
-  finalizeThread(0),
-  jniReferences(0),
-  propertyCount(propertyCount),
-  arguments(arguments),
-  argumentCount(argumentCount),
-  threadCount(0),
-  activeCount(0),
-  liveCount(0),
-  daemonCount(0),
-  fixedFootprint(0),
-  stackSizeInBytes(stackSizeInBytes),
-  localThread(0),
-  stateLock(0),
-  heapLock(0),
-  classLock(0),
-  referenceLock(0),
-  shutdownLock(0),
-  libraries(0),
-  errorLog(0),
-  bootimage(0),
-  types(0),
-  roots(0),
-  finalizers(0),
-  tenuredFinalizers(0),
-  finalizeQueue(0),
-  weakReferences(0),
-  tenuredWeakReferences(0),
-  unsafe(false),
-  collecting(false),
-  triedBuiltinOnLoad(false),
-  dumpedHeapOnOOM(false),
-  alive(true),
-  heapPoolIndex(0)
+Machine::Machine(System* system,
+                 Heap* heap,
+                 Finder* bootFinder,
+                 Finder* appFinder,
+                 Processor* processor,
+                 Classpath* classpath,
+                 const char** properties,
+                 unsigned propertyCount,
+                 const char** arguments,
+                 unsigned argumentCount,
+                 unsigned stackSizeInBytes)
+    : vtable(&javaVMVTable),
+      system(system),
+      heapClient(new (heap->allocate(sizeof(HeapClient))) HeapClient(this)),
+      heap(heap),
+      bootFinder(bootFinder),
+      appFinder(appFinder),
+      processor(processor),
+      classpath(classpath),
+      rootThread(0),
+      exclusive(0),
+      finalizeThread(0),
+      jniReferences(0),
+      propertyCount(propertyCount),
+      arguments(arguments),
+      argumentCount(argumentCount),
+      threadCount(0),
+      activeCount(0),
+      liveCount(0),
+      daemonCount(0),
+      fixedFootprint(0),
+      stackSizeInBytes(stackSizeInBytes),
+      localThread(0),
+      stateLock(0),
+      heapLock(0),
+      classLock(0),
+      referenceLock(0),
+      shutdownLock(0),
+      libraries(0),
+      errorLog(0),
+      bootimage(0),
+      types(0),
+      roots(0),
+      finalizers(0),
+      tenuredFinalizers(0),
+      finalizeQueue(0),
+      weakReferences(0),
+      tenuredWeakReferences(0),
+      unsafe(false),
+      collecting(false),
+      triedBuiltinOnLoad(false),
+      dumpedHeapOnOOM(false),
+      alive(true),
+      heapPoolIndex(0)
 {
   heap->setClient(heapClient);
 
@@ -3252,30 +3667,31 @@ Machine::Machine(System* system, Heap* heap, Finder* bootFinder,
 
   // Copying the properties memory (to avoid memory crashes)
   this->properties = (char**)heap->allocate(sizeof(char*) * propertyCount);
-  for (unsigned int i = 0; i < propertyCount; i++)
-  {
-    size_t length = strlen(properties[i]) + 1; // +1 for null-terminating char
+  for (unsigned int i = 0; i < propertyCount; i++) {
+    size_t length = strlen(properties[i]) + 1;  // +1 for null-terminating char
     this->properties[i] = (char*)heap->allocate(sizeof(char) * length);
     memcpy(this->properties[i], properties[i], length);
   }
 
   const char* bootstrapProperty = findProperty(this, BOOTSTRAP_PROPERTY);
-  const char* bootstrapPropertyDup = bootstrapProperty ? strdup(bootstrapProperty) : 0;
-  const char* bootstrapPropertyEnd = bootstrapPropertyDup + (bootstrapPropertyDup ? strlen(bootstrapPropertyDup) : 0);
+  const char* bootstrapPropertyDup
+      = bootstrapProperty ? strdup(bootstrapProperty) : 0;
+  const char* bootstrapPropertyEnd
+      = bootstrapPropertyDup
+        + (bootstrapPropertyDup ? strlen(bootstrapPropertyDup) : 0);
   char* codeLibraryName = (char*)bootstrapPropertyDup;
   char* codeLibraryNameEnd = 0;
-  if (codeLibraryName && (codeLibraryNameEnd = strchr(codeLibraryName, system->pathSeparator())))
+  if (codeLibraryName && (codeLibraryNameEnd
+                          = strchr(codeLibraryName, system->pathSeparator())))
     *codeLibraryNameEnd = 0;
 
-  if (not system->success(system->make(&localThread)) or
-      not system->success(system->make(&stateLock)) or
-      not system->success(system->make(&heapLock)) or
-      not system->success(system->make(&classLock)) or
-      not system->success(system->make(&referenceLock)) or
-      not system->success(system->make(&shutdownLock)) or
-      not system->success
-      (system->load(&libraries, bootstrapPropertyDup)))
-  {
+  if (not system->success(system->make(&localThread))
+      or not system->success(system->make(&stateLock))
+      or not system->success(system->make(&heapLock))
+      or not system->success(system->make(&classLock))
+      or not system->success(system->make(&referenceLock))
+      or not system->success(system->make(&shutdownLock))
+      or not system->success(system->load(&libraries, bootstrapPropertyDup))) {
     system->abort();
   }
 
@@ -3291,12 +3707,11 @@ Machine::Machine(System* system, Heap* heap, Finder* bootFinder,
     libraries->setNext(additionalLibrary);
   }
 
-  if(bootstrapPropertyDup)
+  if (bootstrapPropertyDup)
     free((void*)bootstrapPropertyDup);
 }
 
-void
-Machine::dispose()
+void Machine::dispose()
 {
   localThread->dispose();
   stateLock->dispose();
@@ -3325,8 +3740,7 @@ Machine::dispose()
 
   heap->free(arguments, sizeof(const char*) * argumentCount);
 
-  for (unsigned int i = 0; i < propertyCount; i++)
-  {
+  for (unsigned int i = 0; i < propertyCount; i++) {
     heap->free(properties[i], sizeof(char) * (strlen(properties[i]) + 1));
   }
   heap->free(properties, sizeof(const char*) * propertyCount);
@@ -3360,10 +3774,10 @@ Thread::Thread(Machine* m, GcThread* javaThread, Thread* parent)
       heap(defaultHeap),
       backupHeapIndex(0),
       flags(ActiveFlag)
-{ }
+{
+}
 
-void
-Thread::init()
+void Thread::init()
 {
   memset(defaultHeap, 0, ThreadHeapSizeInBytes);
   memset(backupHeap, 0, ThreadBackupHeapSizeInBytes);
@@ -3384,8 +3798,7 @@ Thread::init()
     const char* imageFunctionName = findProperty(m, "avian.bootimage");
     if (imageFunctionName) {
       bool lzma = strncmp("lzma:", imageFunctionName, 5) == 0;
-      const char* symbolName
-        = lzma ? imageFunctionName + 5 : imageFunctionName;
+      const char* symbolName = lzma ? imageFunctionName + 5 : imageFunctionName;
 
       void* imagep = m->libraries->resolve(symbolName);
       if (imagep) {
@@ -3396,9 +3809,8 @@ Thread::init()
         uint8_t* imageBytes = imageFunction(&size);
         if (lzma) {
 #ifdef AVIAN_USE_LZMA
-          m->bootimage = image = reinterpret_cast<BootImage*>
-            (decodeLZMA
-             (m->system, m->heap, imageBytes, size, &(m->bootimageSize)));
+          m->bootimage = image = reinterpret_cast<BootImage*>(decodeLZMA(
+              m->system, m->heap, imageBytes, size, &(m->bootimageSize)));
 #else
           abort(this);
 #endif
@@ -3460,12 +3872,9 @@ Thread::init()
   expect(this, m->system->success(m->system->make(&lock)));
 }
 
-void
-Thread::exit()
+void Thread::exit()
 {
-  if (state != Thread::ExitState and
-      state != Thread::ZombieState)
-  {
+  if (state != Thread::ExitState and state != Thread::ZombieState) {
     enter(this, Thread::ExclusiveState);
 
     if (m->liveCount == 1) {
@@ -3478,26 +3887,24 @@ Thread::exit()
   }
 }
 
-void
-Thread::dispose()
+void Thread::dispose()
 {
   if (lock) {
     lock->dispose();
   }
-  
+
   if (systemThread) {
     systemThread->dispose();
   }
 
-  -- m->threadCount;
+  --m->threadCount;
 
   m->heap->free(defaultHeap, ThreadHeapSizeInBytes);
 
   m->processor->dispose(this);
 }
 
-void
-shutDown(Thread* t)
+void shutDown(Thread* t)
 {
   ACQUIRE(t, t->m->shutdownLock);
 
@@ -3519,12 +3926,11 @@ shutDown(Thread* t)
       Thread* ht
           = reinterpret_cast<Thread*>(cast<GcThread>(t, h->first())->peer());
 
-      { ACQUIRE(t, t->m->stateLock);
+      {
+        ACQUIRE(t, t->m->stateLock);
 
-        if (ht == 0
-            or ht->state == Thread::ZombieState
-            or ht->state == Thread::JoinedState)
-        {
+        if (ht == 0 or ht->state == Thread::ZombieState
+            or ht->state == Thread::JoinedState) {
           break;
         } else {
           ENTER(t, Thread::IdleState);
@@ -3535,17 +3941,17 @@ shutDown(Thread* t)
   }
 
   // tell finalize thread to exit and wait for it to do so
-  { ACQUIRE(t, t->m->stateLock);
+  {
+    ACQUIRE(t, t->m->stateLock);
     Thread* finalizeThread = t->m->finalizeThread;
     if (finalizeThread) {
       t->m->finalizeThread = 0;
       t->m->stateLock->notifyAll(t->systemThread);
 
       while (finalizeThread->state != Thread::ZombieState
-             and finalizeThread->state != Thread::JoinedState)
-      {
+             and finalizeThread->state != Thread::JoinedState) {
         ENTER(t, Thread::IdleState);
-        t->m->stateLock->wait(t->systemThread, 0);      
+        t->m->stateLock->wait(t->systemThread, 0);
       }
     }
   }
@@ -3554,7 +3960,8 @@ shutDown(Thread* t)
 
   // todo: be more aggressive about killing daemon threads, e.g. at
   // any GC point, not just at waits/sleeps
-  { ACQUIRE(t, t->m->stateLock);
+  {
+    ACQUIRE(t, t->m->stateLock);
 
     t->m->alive = false;
 
@@ -3562,12 +3969,12 @@ shutDown(Thread* t)
   }
 }
 
-void
-enter(Thread* t, Thread::State s)
+void enter(Thread* t, Thread::State s)
 {
   stress(t);
 
-  if (s == t->state) return;
+  if (s == t->state)
+    return;
 
   if (t->state == Thread::ExitState) {
     // once in exit state, we stay that way
@@ -3575,16 +3982,16 @@ enter(Thread* t, Thread::State s)
   }
 
 #ifdef USE_ATOMIC_OPERATIONS
-#  define INCREMENT atomicIncrement
-#  define ACQUIRE_LOCK ACQUIRE_RAW(t, t->m->stateLock)
-#  define STORE_LOAD_MEMORY_BARRIER storeLoadMemoryBarrier()
+#define INCREMENT atomicIncrement
+#define ACQUIRE_LOCK ACQUIRE_RAW(t, t->m->stateLock)
+#define STORE_LOAD_MEMORY_BARRIER storeLoadMemoryBarrier()
 #else
-#  define INCREMENT(pointer, value) *(pointer) += value;
-#  define ACQUIRE_LOCK
-#  define STORE_LOAD_MEMORY_BARRIER
+#define INCREMENT(pointer, value) *(pointer) += value;
+#define ACQUIRE_LOCK
+#define STORE_LOAD_MEMORY_BARRIER
 
   ACQUIRE_RAW(t, t->m->stateLock);
-#endif // not USE_ATOMIC_OPERATIONS
+#endif  // not USE_ATOMIC_OPERATIONS
 
   switch (s) {
   case Thread::ExclusiveState: {
@@ -3597,18 +4004,20 @@ enter(Thread* t, Thread::State s)
     }
 
     switch (t->state) {
-    case Thread::ActiveState: break;
+    case Thread::ActiveState:
+      break;
 
     case Thread::IdleState: {
       INCREMENT(&(t->m->activeCount), 1);
     } break;
 
-    default: abort(t);
+    default:
+      abort(t);
     }
 
     t->state = Thread::ExclusiveState;
     t->m->exclusive = t;
-    
+
     STORE_LOAD_MEMORY_BARRIER;
 
     while (t->m->activeCount > 1) {
@@ -3644,9 +4053,11 @@ enter(Thread* t, Thread::State s)
       t->m->exclusive = 0;
     } break;
 
-    case Thread::ActiveState: break;
+    case Thread::ActiveState:
+      break;
 
-    default: abort(t);
+    default:
+      abort(t);
     }
 
     assertT(t, t->m->activeCount > 0);
@@ -3654,10 +4065,10 @@ enter(Thread* t, Thread::State s)
 
     if (s == Thread::ZombieState) {
       assertT(t, t->m->liveCount > 0);
-      -- t->m->liveCount;
+      --t->m->liveCount;
 
       if (t->flags & Thread::DaemonFlag) {
-        -- t->m->daemonCount;
+        --t->m->daemonCount;
       }
     }
 
@@ -3682,7 +4093,8 @@ enter(Thread* t, Thread::State s)
       }
     }
 
-    { ACQUIRE_LOCK;
+    {
+      ACQUIRE_LOCK;
 
       switch (t->state) {
       case Thread::ExclusiveState: {
@@ -3702,15 +4114,17 @@ enter(Thread* t, Thread::State s)
 
         INCREMENT(&(t->m->activeCount), 1);
         if (t->state == Thread::NoState) {
-          ++ t->m->liveCount;
-          ++ t->m->threadCount;
+          ++t->m->liveCount;
+          ++t->m->threadCount;
         }
         t->state = s;
       } break;
 
-      default: abort(t);
+      default:
+        abort(t);
       }
-    } break;
+    }
+    break;
 
   case Thread::ExitState: {
     ACQUIRE_LOCK;
@@ -3723,9 +4137,11 @@ enter(Thread* t, Thread::State s)
       t->m->stateLock->notifyAll(t->systemThread);
     } break;
 
-    case Thread::ActiveState: break;
+    case Thread::ActiveState:
+      break;
 
-    default: abort(t);
+    default:
+      abort(t);
     }
 
     assertT(t, t->m->activeCount > 0);
@@ -3738,36 +4154,43 @@ enter(Thread* t, Thread::State s)
     }
   } break;
 
-  default: abort(t);
+  default:
+    abort(t);
   }
 }
 
-object
-allocate2(Thread* t, unsigned sizeInBytes, bool objectMask)
+object allocate2(Thread* t, unsigned sizeInBytes, bool objectMask)
 {
-  return allocate3
-    (t, t->m->heap,
-     ceilingDivide(sizeInBytes, BytesPerWord) > ThreadHeapSizeInWords ?
-     Machine::FixedAllocation : Machine::MovableAllocation,
-     sizeInBytes, objectMask);
+  return allocate3(
+      t,
+      t->m->heap,
+      ceilingDivide(sizeInBytes, BytesPerWord) > ThreadHeapSizeInWords
+          ? Machine::FixedAllocation
+          : Machine::MovableAllocation,
+      sizeInBytes,
+      objectMask);
 }
 
-object
-allocate3(Thread* t, Allocator* allocator, Machine::AllocationType type,
-          unsigned sizeInBytes, bool objectMask)
+object allocate3(Thread* t,
+                 Allocator* allocator,
+                 Machine::AllocationType type,
+                 unsigned sizeInBytes,
+                 bool objectMask)
 {
   expect(t, t->criticalLevel == 0);
 
   if (UNLIKELY(t->flags & Thread::UseBackupHeapFlag)) {
-    expect(t,  t->backupHeapIndex + ceilingDivide(sizeInBytes, BytesPerWord)
+    expect(t,
+           t->backupHeapIndex + ceilingDivide(sizeInBytes, BytesPerWord)
            <= ThreadBackupHeapSizeInWords);
-    
+
     object o = reinterpret_cast<object>(t->backupHeap + t->backupHeapIndex);
     t->backupHeapIndex += ceilingDivide(sizeInBytes, BytesPerWord);
     fieldAtOffset<object>(o, 0) = 0;
     return o;
   } else if (UNLIKELY(t->flags & Thread::TracingFlag)) {
-    expect(t, t->heapIndex + ceilingDivide(sizeInBytes, BytesPerWord)
+    expect(t,
+           t->heapIndex + ceilingDivide(sizeInBytes, BytesPerWord)
            <= ThreadHeapSizeInWords);
     return allocateSmall(t, sizeInBytes);
   }
@@ -3783,19 +4206,17 @@ allocate3(Thread* t, Allocator* allocator, Machine::AllocationType type,
       t->m->stateLock->wait(t->systemThread, 0);
     }
   }
-  
+
   do {
     switch (type) {
     case Machine::MovableAllocation:
       if (t->heapIndex + ceilingDivide(sizeInBytes, BytesPerWord)
-          > ThreadHeapSizeInWords)
-      {
+          > ThreadHeapSizeInWords) {
         t->heap = 0;
         if ((not t->m->heap->limitExceeded())
-            and t->m->heapPoolIndex < ThreadHeapPoolSize)
-        {
-          t->heap = static_cast<uintptr_t*>
-            (t->m->heap->tryAllocate(ThreadHeapSizeInBytes));
+            and t->m->heapPoolIndex < ThreadHeapPoolSize) {
+          t->heap = static_cast<uintptr_t*>(
+              t->m->heap->tryAllocate(ThreadHeapSizeInBytes));
 
           if (t->heap) {
             memset(t->heap, 0, ThreadHeapSizeInBytes);
@@ -3809,8 +4230,7 @@ allocate3(Thread* t, Allocator* allocator, Machine::AllocationType type,
       break;
 
     case Machine::FixedAllocation:
-      if (t->m->fixedFootprint + sizeInBytes > FixedFootprintThresholdInBytes)
-      {
+      if (t->m->fixedFootprint + sizeInBytes > FixedFootprintThresholdInBytes) {
         t->heap = 0;
       }
       break;
@@ -3819,8 +4239,8 @@ allocate3(Thread* t, Allocator* allocator, Machine::AllocationType type,
       break;
     }
 
-    int pendingAllocation = t->m->heap->fixedFootprint
-      (ceilingDivide(sizeInBytes, BytesPerWord), objectMask);
+    int pendingAllocation = t->m->heap->fixedFootprint(
+        ceilingDivide(sizeInBytes, BytesPerWord), objectMask);
 
     if (t->heap == 0 or t->m->heap->limitExceeded(pendingAllocation)) {
       //     fprintf(stderr, "gc");
@@ -3833,7 +4253,7 @@ allocate3(Thread* t, Allocator* allocator, Machine::AllocationType type,
     }
   } while (type == Machine::MovableAllocation
            and t->heapIndex + ceilingDivide(sizeInBytes, BytesPerWord)
-           > ThreadHeapSizeInWords);
+               > ThreadHeapSizeInWords);
 
   switch (type) {
   case Machine::MovableAllocation: {
@@ -3841,24 +4261,22 @@ allocate3(Thread* t, Allocator* allocator, Machine::AllocationType type,
   }
 
   case Machine::FixedAllocation: {
-    object o = static_cast<object>
-      (t->m->heap->allocateFixed
-       (allocator, ceilingDivide(sizeInBytes, BytesPerWord), objectMask));
+    object o = static_cast<object>(t->m->heap->allocateFixed(
+        allocator, ceilingDivide(sizeInBytes, BytesPerWord), objectMask));
 
     memset(o, 0, sizeInBytes);
 
     alias(o, 0) = FixedMark;
-    
-    t->m->fixedFootprint += t->m->heap->fixedFootprint
-      (ceilingDivide(sizeInBytes, BytesPerWord), objectMask);
-      
+
+    t->m->fixedFootprint += t->m->heap->fixedFootprint(
+        ceilingDivide(sizeInBytes, BytesPerWord), objectMask);
+
     return o;
   }
 
   case Machine::ImmortalAllocation: {
-    object o = static_cast<object>
-      (t->m->heap->allocateImmortalFixed
-       (allocator, ceilingDivide(sizeInBytes, BytesPerWord), objectMask));
+    object o = static_cast<object>(t->m->heap->allocateImmortalFixed(
+        allocator, ceilingDivide(sizeInBytes, BytesPerWord), objectMask));
 
     memset(o, 0, sizeInBytes);
 
@@ -3867,17 +4285,17 @@ allocate3(Thread* t, Allocator* allocator, Machine::AllocationType type,
     return o;
   }
 
-  default: abort(t);
+  default:
+    abort(t);
   }
 }
 
-void
-collect(Thread* t, Heap::CollectionType type, int pendingAllocation)
+void collect(Thread* t, Heap::CollectionType type, int pendingAllocation)
 {
   ENTER(t, Thread::ExclusiveState);
 
   unsigned pending = pendingAllocation
-    - (t->m->heapPoolIndex * ThreadHeapSizeInWords);
+                     - (t->m->heapPoolIndex * ThreadHeapSizeInWords);
 
   if (t->m->heap->limitExceeded(pending)) {
     type = Heap::MajorCollection;
@@ -3915,8 +4333,7 @@ object makeNewGeneral(Thread* t, GcClass* class_)
   return instance;
 }
 
-void
-popResources(Thread* t)
+void popResources(Thread* t)
 {
   while (t->resource != t->checkpoint->resource) {
     Thread::Resource* r = t->resource;
@@ -3930,7 +4347,7 @@ popResources(Thread* t)
 GcByteArray* makeByteArrayV(Thread* t, const char* format, va_list a, int size)
 {
   THREAD_RUNTIME_ARRAY(t, char, buffer, size);
-  
+
   int r = vm::vsnprintf(RUNTIME_ARRAY_BODY(buffer), size - 1, format, a);
   if (r >= 0 and r < size - 1) {
     GcByteArray* s = makeByteArray(t, strlen(RUNTIME_ARRAY_BODY(buffer)) + 1);
@@ -3990,10 +4407,14 @@ int stringUTFLength(Thread* t,
       GcCharArray* a = cast<GcCharArray>(t, data);
       for (unsigned i = 0; i < length; ++i) {
         uint16_t c = a->body()[string->offset(t) + start + i];
-        if (c == 0)         result += 1; // null char (was 2 bytes in Java)
-        else if (c < 0x80)  result += 1; // ASCII char
-        else if (c < 0x800) result += 2; // two-byte char
-        else                result += 3; // three-byte char
+        if (c == 0)
+          result += 1;  // null char (was 2 bytes in Java)
+        else if (c < 0x80)
+          result += 1;  // ASCII char
+        else if (c < 0x800)
+          result += 2;  // two-byte char
+        else
+          result += 3;  // three-byte char
       }
     }
   }
@@ -4066,14 +4487,14 @@ void stringUTFChars(Thread* t,
     int j = 0;
     for (unsigned i = 0; i < length; ++i) {
       uint16_t c = cs->body()[string->offset(t) + start + i];
-      if(!c) {                // null char
+      if (!c) {  // null char
         chars[j++] = 0;
       } else if (c < 0x80) {  // ASCII char
         chars[j++] = static_cast<char>(c);
-      } else if (c < 0x800) { // two-byte char
+      } else if (c < 0x800) {  // two-byte char
         chars[j++] = static_cast<char>(0x0c0 | (c >> 6));
         chars[j++] = static_cast<char>(0x080 | (c & 0x03f));
-      } else {                // three-byte char
+      } else {  // three-byte char
         chars[j++] = static_cast<char>(0x0e0 | ((c >> 12) & 0x0f));
         chars[j++] = static_cast<char>(0x080 | ((c >> 6) & 0x03f));
         chars[j++] = static_cast<char>(0x080 | (c & 0x03f));
@@ -4083,8 +4504,7 @@ void stringUTFChars(Thread* t,
   }
 }
 
-uint64_t
-resolveBootstrap(Thread* t, uintptr_t* arguments)
+uint64_t resolveBootstrap(Thread* t, uintptr_t* arguments)
 {
   GcByteArray* name
       = cast<GcByteArray>(t, reinterpret_cast<object>(arguments[0]));
@@ -4099,7 +4519,8 @@ bool isAssignableFrom(Thread* t, GcClass* a, GcClass* b)
   assertT(t, a);
   assertT(t, b);
 
-  if (a == b) return true;
+  if (a == b)
+    return true;
 
   if (a->flags() & ACC_INTERFACE) {
     if (b->vmFlags() & BootstrapFlag) {
@@ -4160,8 +4581,7 @@ GcMethod* classInitializer(Thread* t, GcClass* class_)
   return 0;
 }
 
-unsigned
-fieldCode(Thread* t, unsigned javaCode)
+unsigned fieldCode(Thread* t, unsigned javaCode)
 {
   switch (javaCode) {
   case 'B':
@@ -4186,12 +4606,12 @@ fieldCode(Thread* t, unsigned javaCode)
   case '[':
     return ObjectField;
 
-  default: abort(t);
+  default:
+    abort(t);
   }
 }
 
-unsigned
-fieldType(Thread* t, unsigned code)
+unsigned fieldType(Thread* t, unsigned code)
 {
   switch (code) {
   case VoidField:
@@ -4213,12 +4633,12 @@ fieldType(Thread* t, unsigned code)
   case ObjectField:
     return POINTER_TYPE;
 
-  default: abort(t);
+  default:
+    abort(t);
   }
 }
 
-unsigned
-primitiveSize(Thread* t, unsigned code)
+unsigned primitiveSize(Thread* t, unsigned code)
 {
   switch (code) {
   case VoidField:
@@ -4236,7 +4656,8 @@ primitiveSize(Thread* t, unsigned code)
   case LongField:
     return 8;
 
-  default: abort(t);
+  default:
+    abort(t);
   }
 }
 
@@ -4248,11 +4669,14 @@ GcClass* parseClass(Thread* t,
 {
   PROTECT(t, loader);
 
-  class Client: public Stream::Client {
+  class Client : public Stream::Client {
    public:
-    Client(Thread* t): t(t) { }
+    Client(Thread* t) : t(t)
+    {
+    }
 
-    virtual void NO_RETURN handleError() {
+    virtual void NO_RETURN handleError()
+    {
       abort(t);
     }
 
@@ -4264,9 +4688,9 @@ GcClass* parseClass(Thread* t,
 
   uint32_t magic = s.read4();
   expect(t, magic == 0xCAFEBABE);
-  unsigned minorVer = s.read2(); // minor version
-  unsigned majorVer = s.read2(); // major version
-  if(DebugClassReader) {
+  unsigned minorVer = s.read2();  // minor version
+  unsigned majorVer = s.read2();  // major version
+  if (DebugClassReader) {
     fprintf(stderr, "read class (minor %d major %d)\n", minorVer, majorVer);
   }
 
@@ -4299,7 +4723,7 @@ GcClass* parseClass(Thread* t,
       0,   // source
       0);  // vtable length
   PROTECT(t, class_);
-  
+
   unsigned super = s.read2();
   if (super) {
     GcClass* sc = resolveClass(
@@ -4315,10 +4739,10 @@ GcClass* parseClass(Thread* t,
                                            | HasFinalizerFlag | NeedInitFlag));
   }
 
-  if(DebugClassReader) {
+  if (DebugClassReader) {
     fprintf(stderr, "  flags %d name %d super %d\n", flags, name, super);
   }
-  
+
   parseInterfaceTable(t, s, class_, pool, throwType);
 
   parseFieldTable(t, s, class_, pool);
@@ -4373,16 +4797,15 @@ GcClass* parseClass(Thread* t,
   return real;
 }
 
-uint64_t
-runParseClass(Thread* t, uintptr_t* arguments)
+uint64_t runParseClass(Thread* t, uintptr_t* arguments)
 {
   GcClassLoader* loader
       = cast<GcClassLoader>(t, reinterpret_cast<object>(arguments[0]));
   System::Region* region = reinterpret_cast<System::Region*>(arguments[1]);
   Gc::Type throwType = static_cast<Gc::Type>(arguments[2]);
 
-  return reinterpret_cast<uintptr_t>
-    (parseClass(t, loader, region->start(), region->length(), throwType));
+  return reinterpret_cast<uintptr_t>(
+      parseClass(t, loader, region->start(), region->length(), throwType));
 }
 
 GcClass* resolveSystemClass(Thread* t,
@@ -4432,11 +4855,12 @@ GcClass* resolveSystemClass(Thread* t,
           fprintf(stderr, "parsing %s\n", spec->body().begin());
         }
 
-        { THREAD_RESOURCE(t, System::Region*, region, region->dispose());
+        {
+          THREAD_RESOURCE(t, System::Region*, region, region->dispose());
 
-          uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(loader),
-                                    reinterpret_cast<uintptr_t>(region),
-                                    static_cast<uintptr_t>(throwType) };
+          uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(loader),
+                                   reinterpret_cast<uintptr_t>(region),
+                                   static_cast<uintptr_t>(throwType)};
 
           // parse class file
           class_ = cast<GcClass>(
@@ -4483,7 +4907,7 @@ GcClass* resolveSystemClass(Thread* t,
 
         if (bootstrapClass) {
           PROTECT(t, bootstrapClass);
-          
+
           updateBootstrapClass(t, bootstrapClass, class_);
           class_ = bootstrapClass;
         }
@@ -4556,7 +4980,7 @@ GcClass* resolveClass(Thread* t,
             resolveSystemClass(
                 t, roots(t)->bootLoader(), classLoaderClass->name());
           }
-        }      
+        }
       }
 
       GcMethod* method = findVirtualMethod(
@@ -4573,9 +4997,9 @@ GcClass* resolveClass(Thread* t,
       GcString* specString = makeString(t, "%s", RUNTIME_ARRAY_BODY(s));
       PROTECT(t, specString);
 
-      uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(method),
-                                reinterpret_cast<uintptr_t>(loader),
-                                reinterpret_cast<uintptr_t>(specString) };
+      uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(method),
+                               reinterpret_cast<uintptr_t>(loader),
+                               reinterpret_cast<uintptr_t>(specString)};
 
       GcJclass* jc = cast<GcJclass>(
           t, reinterpret_cast<object>(runRaw(t, invokeLoadClass, arguments)));
@@ -4907,8 +5331,7 @@ object findInHierarchyOrNull(
   return o;
 }
 
-unsigned
-parameterFootprint(Thread* t, const char* s, bool static_)
+unsigned parameterFootprint(Thread* t, const char* s, bool static_)
 {
   unsigned footprint = 0;
   for (MethodSpecIterator it(t, s); it.hasNext();) {
@@ -4919,19 +5342,18 @@ parameterFootprint(Thread* t, const char* s, bool static_)
       break;
 
     default:
-      ++ footprint;
-      break;        
+      ++footprint;
+      break;
     }
   }
 
   if (not static_) {
-    ++ footprint;
+    ++footprint;
   }
   return footprint;
 }
 
-void
-addFinalizer(Thread* t, object target, void (*finalize)(Thread*, object))
+void addFinalizer(Thread* t, object target, void (*finalize)(Thread*, object))
 {
   PROTECT(t, target);
 
@@ -4962,14 +5384,15 @@ GcMonitor* objectMonitor(Thread* t, object o, bool createNew)
     PROTECT(t, o);
     PROTECT(t, m);
 
-    { ENTER(t, Thread::ExclusiveState);
+    {
+      ENTER(t, Thread::ExclusiveState);
 
       m = hashMapFind(t, roots(t)->monitorMap(), o, objectHash, objectEqual);
 
       if (m) {
         if (DebugMonitors) {
-          fprintf(stderr, "found monitor %p for object %x\n",
-                  m, objectHash(t, o));
+          fprintf(
+              stderr, "found monitor %p for object %x\n", m, objectHash(t, o));
         }
 
         return cast<GcMonitor>(t, m);
@@ -4979,8 +5402,7 @@ GcMonitor* objectMonitor(Thread* t, object o, bool createNew)
       m = makeMonitor(t, 0, 0, 0, head, head, 0);
 
       if (DebugMonitors) {
-        fprintf(stderr, "made monitor %p for object %x\n", m,
-                objectHash(t, o));
+        fprintf(stderr, "made monitor %p for object %x\n", m, objectHash(t, o));
       }
 
       hashMapInsert(t, roots(t)->monitorMap(), o, m, objectHash);
@@ -4994,8 +5416,7 @@ GcMonitor* objectMonitor(Thread* t, object o, bool createNew)
   }
 }
 
-object
-intern(Thread* t, object s)
+object intern(Thread* t, object s)
 {
   PROTECT(t, s);
 
@@ -5013,8 +5434,7 @@ intern(Thread* t, object s)
   }
 }
 
-void
-walk(Thread* t, Heap::Walker* w, object o, unsigned start)
+void walk(Thread* t, Heap::Walker* w, object o, unsigned start)
 {
   GcClass* class_ = t->m->heap->follow(objectClass(t, o));
   GcIntArray* objectMask = t->m->heap->follow(class_->objectMask());
@@ -5024,17 +5444,22 @@ walk(Thread* t, Heap::Walker* w, object o, unsigned start)
   if (objectMask) {
     unsigned fixedSize = class_->fixedSize();
     unsigned arrayElementSize = class_->arrayElementSize();
-    unsigned arrayLength
-      = (arrayElementSize ?
-         fieldAtOffset<uintptr_t>(o, fixedSize - BytesPerWord) : 0);
+    unsigned arrayLength = (arrayElementSize ? fieldAtOffset<uintptr_t>(
+                                                   o, fixedSize - BytesPerWord)
+                                             : 0);
 
     THREAD_RUNTIME_ARRAY(t, uint32_t, mask, objectMask->length());
     memcpy(RUNTIME_ARRAY_BODY(mask),
            objectMask->body().begin(),
            objectMask->length() * 4);
 
-    more = ::walk(t, w, RUNTIME_ARRAY_BODY(mask), fixedSize, arrayElementSize,
-                  arrayLength, start);
+    more = ::walk(t,
+                  w,
+                  RUNTIME_ARRAY_BODY(mask),
+                  fixedSize,
+                  arrayElementSize,
+                  arrayLength,
+                  start);
   } else if (class_->vmFlags() & SingletonFlag) {
     GcSingleton* s = cast<GcSingleton>(t, o);
     unsigned length = s->length();
@@ -5058,14 +5483,16 @@ walk(Thread* t, Heap::Walker* w, object o, unsigned start)
   }
 }
 
-int
-walkNext(Thread* t, object o, int previous)
+int walkNext(Thread* t, object o, int previous)
 {
-  class Walker: public Heap::Walker {
+  class Walker : public Heap::Walker {
    public:
-    Walker(): value(-1) { }
+    Walker() : value(-1)
+    {
+    }
 
-    bool visit(unsigned offset) {
+    bool visit(unsigned offset)
+    {
       value = offset;
       return false;
     }
@@ -5077,8 +5504,7 @@ walkNext(Thread* t, object o, int previous)
   return walker.value;
 }
 
-void
-visitRoots(Machine* m, Heap::Visitor* v)
+void visitRoots(Machine* m, Heap::Visitor* v)
 {
   v->visit(&(m->types));
   v->visit(&(m->roots));
@@ -5094,27 +5520,26 @@ visitRoots(Machine* m, Heap::Visitor* v)
   }
 }
 
-void
-logTrace(FILE* f, const char* fmt, ...)
+void logTrace(FILE* f, const char* fmt, ...)
 {
-    va_list a;
-    va_start(a, fmt);
+  va_list a;
+  va_start(a, fmt);
 #ifdef PLATFORM_WINDOWS
-    const unsigned length = _vscprintf(fmt, a);
+  const unsigned length = _vscprintf(fmt, a);
 #else
-    const unsigned length = vsnprintf(0, 0, fmt, a);
+  const unsigned length = vsnprintf(0, 0, fmt, a);
 #endif
-    va_end(a);
+  va_end(a);
 
-    RUNTIME_ARRAY(char, buffer, length + 1);
-    va_start(a, fmt);
-    vsnprintf(RUNTIME_ARRAY_BODY(buffer), length + 1, fmt, a);
-    va_end(a);
-    RUNTIME_ARRAY_BODY(buffer)[length] = 0;
+  RUNTIME_ARRAY(char, buffer, length + 1);
+  va_start(a, fmt);
+  vsnprintf(RUNTIME_ARRAY_BODY(buffer), length + 1, fmt, a);
+  va_end(a);
+  RUNTIME_ARRAY_BODY(buffer)[length] = 0;
 
-    ::fprintf(f, "%s", RUNTIME_ARRAY_BODY(buffer));
+  ::fprintf(f, "%s", RUNTIME_ARRAY_BODY(buffer));
 #ifdef PLATFORM_WINDOWS
-    ::OutputDebugStringA(RUNTIME_ARRAY_BODY(buffer));
+  ::OutputDebugStringA(RUNTIME_ARRAY_BODY(buffer));
 #endif
 }
 
@@ -5173,14 +5598,16 @@ void printTrace(Thread* t, GcThrowable* exception)
   ::fflush(errorLog(t));
 }
 
-object
-makeTrace(Thread* t, Processor::StackWalker* walker)
+object makeTrace(Thread* t, Processor::StackWalker* walker)
 {
-  class Visitor: public Processor::StackVisitor {
+  class Visitor : public Processor::StackVisitor {
    public:
-    Visitor(Thread* t): t(t), trace(0), index(0), protector(t, &trace) { }
+    Visitor(Thread* t) : t(t), trace(0), index(0), protector(t, &trace)
+    {
+    }
 
-    virtual bool visit(Processor::StackWalker* walker) {
+    virtual bool visit(Processor::StackWalker* walker)
+    {
       if (trace == 0) {
         trace = makeObjectArray(t, walker->count());
         assertT(t, trace);
@@ -5189,7 +5616,7 @@ makeTrace(Thread* t, Processor::StackWalker* walker)
       GcTraceElement* e = makeTraceElement(t, walker->method(), walker->ip());
       assertT(t, index < objectArrayLength(t, trace));
       reinterpret_cast<GcArray*>(trace)->setBodyElement(t, index, e);
-      ++ index;
+      ++index;
       return true;
     }
 
@@ -5204,14 +5631,16 @@ makeTrace(Thread* t, Processor::StackWalker* walker)
   return v.trace ? v.trace : makeObjectArray(t, 0);
 }
 
-object
-makeTrace(Thread* t, Thread* target)
+object makeTrace(Thread* t, Thread* target)
 {
-  class Visitor: public Processor::StackVisitor {
+  class Visitor : public Processor::StackVisitor {
    public:
-    Visitor(Thread* t): t(t), trace(0) { }
+    Visitor(Thread* t) : t(t), trace(0)
+    {
+    }
 
-    virtual bool visit(Processor::StackWalker* walker) {
+    virtual bool visit(Processor::StackWalker* walker)
+    {
       trace = vm::makeTrace(t, walker);
       return false;
     }
@@ -5225,8 +5654,7 @@ makeTrace(Thread* t, Thread* target)
   return v.trace ? v.trace : makeObjectArray(t, 0);
 }
 
-void
-runFinalizeThread(Thread* t)
+void runFinalizeThread(Thread* t)
 {
   GcFinalizer* finalizeList = 0;
   PROTECT(t, finalizeList);
@@ -5235,7 +5663,8 @@ runFinalizeThread(Thread* t)
   PROTECT(t, cleanList);
 
   while (true) {
-    { ACQUIRE(t, t->m->stateLock);
+    {
+      ACQUIRE(t, t->m->stateLock);
 
       while (t->m->finalizeThread and roots(t)->objectsToFinalize() == 0
              and roots(t)->objectsToClean() == 0) {
@@ -5264,15 +5693,18 @@ runFinalizeThread(Thread* t)
   }
 }
 
-object
-parseUtf8(Thread* t, const char* data, unsigned length)
+object parseUtf8(Thread* t, const char* data, unsigned length)
 {
-  class Client: public Stream::Client {
+  class Client : public Stream::Client {
    public:
-    Client(Thread* t): t(t) { }
+    Client(Thread* t) : t(t)
+    {
+    }
 
-    virtual void handleError() {
-      if (false) abort(t);
+    virtual void handleError()
+    {
+      if (false)
+        abort(t);
     }
 
    private:
@@ -5294,28 +5726,33 @@ object parseUtf8(Thread* t, GcByteArray* array)
 
   return array;
 
- slow_path:
-  class Client: public Stream::Client {
+slow_path:
+  class Client : public Stream::Client {
    public:
-    Client(Thread* t): t(t) { }
+    Client(Thread* t) : t(t)
+    {
+    }
 
-    virtual void handleError() {
-      if (false) abort(t);
+    virtual void handleError()
+    {
+      if (false)
+        abort(t);
     }
 
    private:
     Thread* t;
   } client(t);
 
-  class MyStream: public AbstractStream {
+  class MyStream : public AbstractStream {
    public:
-    class MyProtector: public Thread::Protector {
+    class MyProtector : public Thread::Protector {
      public:
-      MyProtector(Thread* t, MyStream* s):
-        Protector(t), s(s)
-      { }
+      MyProtector(Thread* t, MyStream* s) : Protector(t), s(s)
+      {
+      }
 
-      virtual void visit(Heap::Visitor* v) {
+      virtual void visit(Heap::Visitor* v)
+      {
         v->visit(&(s->array));
       }
 
@@ -5326,9 +5763,11 @@ object parseUtf8(Thread* t, GcByteArray* array)
         : AbstractStream(client, array->length() - 1),
           array(array),
           protector(t, this)
-    { }
+    {
+    }
 
-    virtual void copy(uint8_t* dst, unsigned offset, unsigned size) {
+    virtual void copy(uint8_t* dst, unsigned offset, unsigned size)
+    {
       memcpy(dst, &array->body()[offset], size);
     }
 
@@ -5345,14 +5784,19 @@ GcMethod* getCaller(Thread* t, unsigned target, bool skipMethodInvoke)
     target = 2;
   }
 
-  class Visitor: public Processor::StackVisitor {
+  class Visitor : public Processor::StackVisitor {
    public:
-    Visitor(Thread* t, unsigned target, bool skipMethodInvoke):
-      t(t), method(0), count(0), target(target),
-      skipMethodInvoke(skipMethodInvoke)
-    { }
+    Visitor(Thread* t, unsigned target, bool skipMethodInvoke)
+        : t(t),
+          method(0),
+          count(0),
+          target(target),
+          skipMethodInvoke(skipMethodInvoke)
+    {
+    }
 
-    virtual bool visit(Processor::StackWalker* walker) {
+    virtual bool visit(Processor::StackWalker* walker)
+    {
       if (skipMethodInvoke
           and walker->method()->class_() == type(t, GcJmethod::Type)
           and strcmp(walker->method()->name()->body().begin(),
@@ -5364,7 +5808,7 @@ GcMethod* getCaller(Thread* t, unsigned target, bool skipMethodInvoke)
         method = walker->method();
         return false;
       } else {
-        ++ count;
+        ++count;
         return true;
       }
     }
@@ -5374,7 +5818,7 @@ GcMethod* getCaller(Thread* t, unsigned target, bool skipMethodInvoke)
     unsigned count;
     unsigned target;
     bool skipMethodInvoke;
-    } v(t, target, skipMethodInvoke);
+  } v(t, target, skipMethodInvoke);
 
   t->m->processor->walkStack(t, &v);
 
@@ -5389,7 +5833,7 @@ object defineClass(Thread* t,
   PROTECT(t, loader);
 
   object c = parseClass(t, loader, buffer, length);
-  
+
   // char name[byteArrayLength(t, className(t, c))];
   // memcpy(name, &byteArrayBody(t, className(t, c), 0),
   //        byteArrayLength(t, className(t, c)));
@@ -5412,9 +5856,11 @@ object defineClass(Thread* t,
   return c;
 }
 
-void
-populateMultiArray(Thread* t, object array, int32_t* counts,
-                   unsigned index, unsigned dimensions)
+void populateMultiArray(Thread* t,
+                        object array,
+                        int32_t* counts,
+                        unsigned index,
+                        unsigned dimensions)
 {
   if (index + 1 == dimensions or counts[index] == 0) {
     return;
@@ -5468,8 +5914,7 @@ object interruptLock(Thread* t, GcThread* thread)
   return thread->interruptLock();
 }
 
-void
-clearInterrupted(Thread* t)
+void clearInterrupted(Thread* t)
 {
   monitorAcquire(t, cast<GcMonitor>(t, interruptLock(t, t->javaThread)));
   t->javaThread->interrupted() = false;
@@ -5502,27 +5947,28 @@ bool threadIsInterrupted(Thread* t, GcThread* thread, bool clear)
   return v;
 }
 
-void
-noop()
-{ }
+void noop()
+{
+}
 
 #include "type-constructors.cpp"
 
-} // namespace vm
+}  // namespace vm
 
 // for debugging
-AVIAN_EXPORT void
-vmfPrintTrace(Thread* t, FILE* out)
+AVIAN_EXPORT void vmfPrintTrace(Thread* t, FILE* out)
 {
-  class Visitor: public Processor::StackVisitor {
+  class Visitor : public Processor::StackVisitor {
    public:
-    Visitor(Thread* t, FILE* out): t(t), out(out) { }
+    Visitor(Thread* t, FILE* out) : t(t), out(out)
+    {
+    }
 
-    virtual bool visit(Processor::StackWalker* walker) {
+    virtual bool visit(Processor::StackWalker* walker)
+    {
       const int8_t* class_ = walker->method()->class_()->name()->body().begin();
       const int8_t* method = walker->method()->name()->body().begin();
-      int line = t->m->processor->lineNumber
-        (t, walker->method(), walker->ip());
+      int line = t->m->processor->lineNumber(t, walker->method(), walker->ip());
 
       fprintf(out, "  at %s.%s ", class_, method);
 
@@ -5551,8 +5997,7 @@ vmfPrintTrace(Thread* t, FILE* out)
   fflush(out);
 }
 
-AVIAN_EXPORT void
-vmPrintTrace(Thread* t)
+AVIAN_EXPORT void vmPrintTrace(Thread* t)
 {
   vmfPrintTrace(t, stderr);
 }
@@ -5569,12 +6014,11 @@ AVIAN_EXPORT void* vmAddressFromLine(GcMethod* m, unsigned line)
     unsigned last = 0;
     unsigned bottom = 0;
     unsigned top = lnt->length();
-    for(unsigned i = bottom; i < top; i++)
-    {
+    for (unsigned i = bottom; i < top; i++) {
       uint64_t ln = lnt->body()[i];
-      if(lineNumberLine(ln) == line)
+      if (lineNumberLine(ln) == line)
         return reinterpret_cast<void*>(lineNumberIp(ln));
-      else if(lineNumberLine(ln) > line)
+      else if (lineNumberLine(ln) > line)
         return reinterpret_cast<void*>(last);
       last = lineNumberIp(ln);
     }
diff --git a/src/main.cpp b/src/main.cpp
index 7acb9e8783..dad5a1a768 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -19,30 +19,32 @@
 #include <avian/util/runtime-array.h>
 
 #if (defined __MINGW32__) || (defined _MSC_VER)
-#  define PATH_SEPARATOR ';'
+#define PATH_SEPARATOR ';'
 #else
-#  define PATH_SEPARATOR ':'
+#define PATH_SEPARATOR ':'
 #endif
 
 #ifdef _MSC_VER
 
-#  define not !
-#  define or ||
-#  define and &&
-#  define xor ^
+#define not!
+#define or ||
+#define and &&
+#define xor ^
 
-#endif // not _MSC_VER
+#endif  // not _MSC_VER
 
 #ifdef BOOT_LIBRARY
 
 // since we aren't linking against libstdc++, we must implement this
 // ourselves:
-extern "C" void __cxa_pure_virtual(void) { abort(); }
+extern "C" void __cxa_pure_virtual(void)
+{
+  abort();
+}
 
 // we link against a System implmentation, which requires this at link
 // time, but it should not be used at runtime:
-extern "C" uint64_t
-vmNativeCall(void*, void*, unsigned, unsigned)
+extern "C" uint64_t vmNativeCall(void*, void*, unsigned, unsigned)
 {
   abort();
   // abort is not declared __declspec(noreturn) on MSVC, so we have to
@@ -50,12 +52,11 @@ vmNativeCall(void*, void*, unsigned, unsigned)
   return 0;
 }
 
-#endif // BOOT_LIBRARY
+#endif  // BOOT_LIBRARY
 
 namespace {
 
-const char*
-mainClass(const char* jar)
+const char* mainClass(const char* jar)
 {
   using namespace vm;
 
@@ -63,13 +64,17 @@ mainClass(const char* jar)
 
   class MyAllocator : public avian::util::Allocator {
    public:
-    MyAllocator(System* s): s(s) { }
+    MyAllocator(System* s) : s(s)
+    {
+    }
 
-    virtual void* tryAllocate(unsigned size) {
+    virtual void* tryAllocate(unsigned size)
+    {
       return s->tryAllocate(size);
     }
 
-    virtual void* allocate(unsigned size) {
+    virtual void* allocate(unsigned size)
+    {
       void* p = tryAllocate(size);
       if (p == 0) {
         abort(s);
@@ -77,7 +82,8 @@ mainClass(const char* jar)
       return p;
     }
 
-    virtual void free(const void* p, unsigned) {
+    virtual void free(const void* p, unsigned)
+    {
       s->free(p);
     }
 
@@ -94,11 +100,12 @@ mainClass(const char* jar)
     unsigned length;
     while (readLine(region->start(), region->length(), &start, &length)) {
       const unsigned PrefixLength = 12;
-      if (strncasecmp("Main-Class: ", reinterpret_cast<const char*>
-                      (region->start() + start), PrefixLength) == 0)
-      {
+      if (strncasecmp("Main-Class: ",
+                      reinterpret_cast<const char*>(region->start() + start),
+                      PrefixLength) == 0) {
         result = static_cast<char*>(malloc(length + 1 - PrefixLength));
-        memcpy(result, region->start() + start + PrefixLength,
+        memcpy(result,
+               region->start() + start + PrefixLength,
                length - PrefixLength);
         result[length - PrefixLength] = 0;
         break;
@@ -116,26 +123,26 @@ mainClass(const char* jar)
   return result;
 }
 
-void
-usageAndExit(const char* name)
+void usageAndExit(const char* name)
 {
-  fprintf
-    (stderr, "usage: %s\n"
-     "\t[{-cp|-classpath} <classpath>]\n"
-     "\t[-Xmx<maximum heap size>]\n"
-     "\t[-Xss<maximum stack size>]\n"
-     "\t[-Xbootclasspath/p:<classpath to prepend to bootstrap classpath>]\n"
-     "\t[-Xbootclasspath:<bootstrap classpath>]\n"
-     "\t[-Xbootclasspath/a:<classpath to append to bootstrap classpath>]\n"
-     "\t[-D<property name>=<property value> ...]\n"
-     "\t{<class name>|-jar <app jar>} [<argument> ...]\n", name);
+  fprintf(
+      stderr,
+      "usage: %s\n"
+      "\t[{-cp|-classpath} <classpath>]\n"
+      "\t[-Xmx<maximum heap size>]\n"
+      "\t[-Xss<maximum stack size>]\n"
+      "\t[-Xbootclasspath/p:<classpath to prepend to bootstrap classpath>]\n"
+      "\t[-Xbootclasspath:<bootstrap classpath>]\n"
+      "\t[-Xbootclasspath/a:<classpath to append to bootstrap classpath>]\n"
+      "\t[-D<property name>=<property value> ...]\n"
+      "\t{<class name>|-jar <app jar>} [<argument> ...]\n",
+      name);
   exit(-1);
 }
 
-} // namespace
+}  // namespace
 
-int
-main(int ac, const char** av)
+int main(int ac, const char** av)
 {
   JavaVMInitArgs vmArgs;
   vmArgs.version = JNI_VERSION_1_2;
@@ -178,7 +185,7 @@ main(int ac, const char** av)
 
   if (jar) {
     classpath = jar;
-    
+
     class_ = mainClass(jar);
 
     if (class_ == 0) {
@@ -188,7 +195,7 @@ main(int ac, const char** av)
   }
 
 #ifdef BOOT_LIBRARY
-  ++ vmArgs.nOptions;
+  ++vmArgs.nOptions;
 #endif
 
 #ifdef BOOT_IMAGE
@@ -196,7 +203,7 @@ main(int ac, const char** av)
 #endif
 
 #ifdef BOOT_BUILTINS
-  ++ vmArgs.nOptions;
+  ++vmArgs.nOptions;
 #endif
 
   RUNTIME_ARRAY(JavaVMOption, options, vmArgs.nOptions);
@@ -206,27 +213,27 @@ main(int ac, const char** av)
 
 #ifdef BOOT_IMAGE
   vmArgs.options[optionIndex++].optionString
-    = const_cast<char*>("-Davian.bootimage=bootimageBin");
+      = const_cast<char*>("-Davian.bootimage=bootimageBin");
 
   vmArgs.options[optionIndex++].optionString
-    = const_cast<char*>("-Davian.codeimage=codeimageBin");
+      = const_cast<char*>("-Davian.codeimage=codeimageBin");
 #endif
 
 #ifdef BOOT_LIBRARY
   vmArgs.options[optionIndex++].optionString
-    = const_cast<char*>("-Davian.bootstrap=" BOOT_LIBRARY);
+      = const_cast<char*>("-Davian.bootstrap=" BOOT_LIBRARY);
 #endif
 
 #ifdef BOOT_BUILTINS
   vmArgs.options[optionIndex++].optionString
-    = const_cast<char*>("-Davian.builtins=" BOOT_BUILTINS);
+      = const_cast<char*>("-Davian.builtins=" BOOT_BUILTINS);
 #endif
 
 #define CLASSPATH_PROPERTY "-Djava.class.path="
 
   unsigned classpathSize = strlen(classpath);
-  unsigned classpathPropertyBufferSize
-    = sizeof(CLASSPATH_PROPERTY) + classpathSize;
+  unsigned classpathPropertyBufferSize = sizeof(CLASSPATH_PROPERTY)
+                                         + classpathSize;
 
   RUNTIME_ARRAY(char, classpathPropertyBuffer, classpathPropertyBufferSize);
   memcpy(RUNTIME_ARRAY_BODY(classpathPropertyBuffer),
@@ -238,12 +245,10 @@ main(int ac, const char** av)
          classpathSize + 1);
 
   vmArgs.options[optionIndex++].optionString
-    = RUNTIME_ARRAY_BODY(classpathPropertyBuffer);
+      = RUNTIME_ARRAY_BODY(classpathPropertyBuffer);
 
   for (int i = 1; i < ac; ++i) {
-    if (strncmp(av[i], "-X", 2) == 0
-        or strncmp(av[i], "-D", 2) == 0)
-    {
+    if (strncmp(av[i], "-X", 2) == 0 or strncmp(av[i], "-D", 2) == 0) {
       vmArgs.options[optionIndex++].optionString = const_cast<char*>(av[i]);
     }
   }
@@ -276,7 +281,7 @@ main(int ac, const char** av)
           for (int i = 0; i < argc; ++i) {
             e->SetObjectArrayElement(a, i, e->NewStringUTF(argv[i]));
           }
-          
+
           e->CallStaticVoidMethod(c, m, a);
         }
       }
diff --git a/src/openjdk/jni_md.h b/src/openjdk/jni_md.h
index a14542a68a..aea3786dec 100644
--- a/src/openjdk/jni_md.h
+++ b/src/openjdk/jni_md.h
@@ -14,13 +14,12 @@
 #include "stdint.h"
 
 #if (defined __MINGW32__) || (defined _MSC_VER)
-#  define JNIEXPORT __declspec(dllexport)
-#  define JNICALL __stdcall
-#else // not (defined __MINGW32__) || (defined _MSC_VER)
-#  define JNIEXPORT __attribute__ ((visibility("default"))) \
-  __attribute__ ((used))
-#  define JNICALL
-#endif // not (defined __MINGW32__) || (defined _MSC_VER)
+#define JNIEXPORT __declspec(dllexport)
+#define JNICALL __stdcall
+#else  // not (defined __MINGW32__) || (defined _MSC_VER)
+#define JNIEXPORT __attribute__((visibility("default"))) __attribute__((used))
+#define JNICALL
+#endif  // not (defined __MINGW32__) || (defined _MSC_VER)
 
 #define JNIIMPORT
 
@@ -28,4 +27,4 @@ typedef int32_t jint;
 typedef int64_t jlong;
 typedef int8_t jbyte;
 
-#endif//JNI_MD_H
+#endif  // JNI_MD_H
diff --git a/src/openjdk/stubs.cpp b/src/openjdk/stubs.cpp
index af6a1d15e2..c2175fdd34 100644
--- a/src/openjdk/stubs.cpp
+++ b/src/openjdk/stubs.cpp
@@ -2,14 +2,12 @@
 
 using namespace vm;
 
-extern "C" AVIAN_EXPORT jint JNICALL
-net_JNI_OnLoad(JavaVM*, void*)
+extern "C" AVIAN_EXPORT jint JNICALL net_JNI_OnLoad(JavaVM*, void*)
 {
   return 0;
 }
 
-extern "C" AVIAN_EXPORT jint JNICALL
-management_JNI_OnLoad(JavaVM*, void*)
+extern "C" AVIAN_EXPORT jint JNICALL management_JNI_OnLoad(JavaVM*, void*)
 {
   return 0;
 }
diff --git a/src/process.cpp b/src/process.cpp
index 86609350b1..2034ca5f08 100644
--- a/src/process.cpp
+++ b/src/process.cpp
@@ -16,8 +16,7 @@ using namespace vm;
 
 namespace {
 
-unsigned
-mangledSize(int8_t c)
+unsigned mangledSize(int8_t c)
 {
   switch (c) {
   case '_':
@@ -33,8 +32,7 @@ mangledSize(int8_t c)
   }
 }
 
-unsigned
-mangle(int8_t c, char* dst)
+unsigned mangle(int8_t c, char* dst)
 {
   switch (c) {
   case '/':
@@ -75,7 +73,7 @@ unsigned jniNameLength(Thread* t UNUSED, GcMethod* method, bool decorate)
     size += mangledSize(className->body()[i]);
   }
 
-  ++ size;
+  ++size;
 
   GcByteArray* methodName = method->name();
   for (unsigned i = 0; i < methodName->length() - 1; ++i) {
@@ -117,7 +115,7 @@ void makeJNIName(Thread* t UNUSED,
   for (unsigned i = 0; i < methodName->length() - 1; ++i) {
     name += mangle(methodName->body()[i], name);
   }
-  
+
   if (decorate) {
     *(name++) = '_';
     *(name++) = '_';
@@ -133,8 +131,9 @@ void makeJNIName(Thread* t UNUSED,
   *(name++) = 0;
 }
 
-void*
-resolveNativeMethod(Thread* t, const char* undecorated, const char* decorated)
+void* resolveNativeMethod(Thread* t,
+                          const char* undecorated,
+                          const char* decorated)
 {
   for (System::Library* lib = t->m->libraries; lib; lib = lib->next()) {
     void* p = lib->resolve(undecorated);
@@ -160,16 +159,21 @@ void* resolveNativeMethod(Thread* t,
   unsigned undecoratedSize = prefixLength + jniNameLength(t, method, false);
   // extra 6 is for code below:
   THREAD_RUNTIME_ARRAY(t, char, undecorated, undecoratedSize + 1 + 6);
-  makeJNIName(t, prefix, prefixLength, RUNTIME_ARRAY_BODY(undecorated) + 1,
-              method, false);
+  makeJNIName(t,
+              prefix,
+              prefixLength,
+              RUNTIME_ARRAY_BODY(undecorated) + 1,
+              method,
+              false);
 
   unsigned decoratedSize = prefixLength + jniNameLength(t, method, true);
   // extra 6 is for code below:
   THREAD_RUNTIME_ARRAY(t, char, decorated, decoratedSize + 1 + 6);
-  makeJNIName(t, prefix, prefixLength, RUNTIME_ARRAY_BODY(decorated) + 1,
-              method, true);
+  makeJNIName(
+      t, prefix, prefixLength, RUNTIME_ARRAY_BODY(decorated) + 1, method, true);
 
-  void* p = resolveNativeMethod(t, RUNTIME_ARRAY_BODY(undecorated) + 1,
+  void* p = resolveNativeMethod(t,
+                                RUNTIME_ARRAY_BODY(undecorated) + 1,
                                 RUNTIME_ARRAY_BODY(decorated) + 1);
   if (p) {
     return p;
@@ -180,26 +184,31 @@ void* resolveNativeMethod(Thread* t,
   if (footprint == -1) {
     footprint = methodParameterFootprint(t, method) + 1;
     if (method->flags() & ACC_STATIC) {
-      ++ footprint;
+      ++footprint;
     }
   }
 
   *RUNTIME_ARRAY_BODY(undecorated) = '_';
-  vm::snprintf(RUNTIME_ARRAY_BODY(undecorated) + undecoratedSize + 1, 5, "@%d",
+  vm::snprintf(RUNTIME_ARRAY_BODY(undecorated) + undecoratedSize + 1,
+               5,
+               "@%d",
                footprint * BytesPerWord);
 
   *RUNTIME_ARRAY_BODY(decorated) = '_';
-  vm::snprintf(RUNTIME_ARRAY_BODY(decorated) + decoratedSize + 1, 5, "@%d",
+  vm::snprintf(RUNTIME_ARRAY_BODY(decorated) + decoratedSize + 1,
+               5,
+               "@%d",
                footprint * BytesPerWord);
 
-  p = resolveNativeMethod(t, RUNTIME_ARRAY_BODY(undecorated),
-                          RUNTIME_ARRAY_BODY(decorated));
+  p = resolveNativeMethod(
+      t, RUNTIME_ARRAY_BODY(undecorated), RUNTIME_ARRAY_BODY(decorated));
   if (p) {
     return p;
   }
 
   // one more try without the leading underscore
-  p = resolveNativeMethod(t, RUNTIME_ARRAY_BODY(undecorated) + 1,
+  p = resolveNativeMethod(t,
+                          RUNTIME_ARRAY_BODY(undecorated) + 1,
                           RUNTIME_ARRAY_BODY(decorated) + 1);
   if (p) {
     return p;
@@ -224,7 +233,7 @@ GcNative* resolveNativeMethod(Thread* t, GcMethod* method)
   return 0;
 }
 
-} // namespace
+}  // namespace
 
 namespace vm {
 
@@ -267,7 +276,7 @@ int findLineNumber(Thread* t UNUSED, GcMethod* method, unsigned ip)
 
   // our parameter indicates the instruction following the one we care
   // about, so we back up first:
-  -- ip;
+  --ip;
 
   GcLineNumberTable* lnt = method->code()->lineNumberTable();
   if (lnt) {
@@ -298,4 +307,4 @@ int findLineNumber(Thread* t UNUSED, GcMethod* method, unsigned ip)
   }
 }
 
-} // namespace vm
+}  // namespace vm
diff --git a/src/system/posix.cpp b/src/system/posix.cpp
index 60eb4aadce..1fb94e58e2 100644
--- a/src/system/posix.cpp
+++ b/src/system/posix.cpp
@@ -9,29 +9,29 @@
    details. */
 
 #ifndef __STDC_CONSTANT_MACROS
-#  define __STDC_CONSTANT_MACROS
+#define __STDC_CONSTANT_MACROS
 #endif
 
 #include "sys/types.h"
 #ifdef __APPLE__
-#  include "CoreFoundation/CoreFoundation.h"
-#  include "sys/ucontext.h"
-#  undef assert
+#include "CoreFoundation/CoreFoundation.h"
+#include "sys/ucontext.h"
+#undef assert
 #elif defined(__ANDROID__)
-#  include <asm/sigcontext.h>       /* for sigcontext */
-#  include <asm/signal.h>           /* for stack_t */
-   typedef struct ucontext {
-     unsigned long uc_flags;
-     struct ucontext *uc_link;
-     stack_t uc_stack;
-     struct sigcontext uc_mcontext;
-     unsigned long uc_sigmask;
-   } ucontext_t;
+#include <asm/sigcontext.h> /* for sigcontext */
+#include <asm/signal.h>     /* for stack_t */
+typedef struct ucontext {
+  unsigned long uc_flags;
+  struct ucontext* uc_link;
+  stack_t uc_stack;
+  struct sigcontext uc_mcontext;
+  unsigned long uc_sigmask;
+} ucontext_t;
 #else
-#  if defined __FreeBSD__
-#    include "limits.h"
-#  endif
-#  include "ucontext.h"
+#if defined __FreeBSD__
+#include "limits.h"
+#endif
+#include "ucontext.h"
 #endif
 
 #include "sys/mman.h"
@@ -56,8 +56,7 @@
 #include <avian/system/signal.h>
 #include <avian/util/math.h>
 
-
-#define ACQUIRE(x) MutexResource MAKE_NAME(mutexResource_) (x)
+#define ACQUIRE(x) MutexResource MAKE_NAME(mutexResource_)(x)
 
 using namespace vm;
 using namespace avian::util;
@@ -66,11 +65,13 @@ namespace {
 
 class MutexResource {
  public:
-  MutexResource(pthread_mutex_t& m): m(&m) {
+  MutexResource(pthread_mutex_t& m) : m(&m)
+  {
     pthread_mutex_lock(&m);
   }
 
-  ~MutexResource() {
+  ~MutexResource()
+  {
     pthread_mutex_unlock(m);
   }
 
@@ -92,25 +93,22 @@ const unsigned SignalCount = 3;
 class MySystem;
 MySystem* system;
 
-void
-handleSignal(int signal, siginfo_t* info, void* context);
+void handleSignal(int signal, siginfo_t* info, void* context);
 
-void*
-run(void* r)
+void* run(void* r)
 {
   static_cast<System::Runnable*>(r)->run();
   return 0;
 }
 
-void
-pathOfExecutable(System* s, const char** retBuf, unsigned* size)
+void pathOfExecutable(System* s, const char** retBuf, unsigned* size)
 {
 #ifdef __APPLE__
   CFBundleRef bundle = CFBundleGetMainBundle();
   CFURLRef url = CFBundleCopyExecutableURL(bundle);
   CFStringRef path = CFURLCopyPath(url);
-  path = CFURLCreateStringByReplacingPercentEscapes(kCFAllocatorDefault,
-                path, CFSTR(""));
+  path = CFURLCreateStringByReplacingPercentEscapes(
+      kCFAllocatorDefault, path, CFSTR(""));
   CFIndex pathSize = CFStringGetMaximumSizeOfFileSystemRepresentation(path);
   char* buffer = reinterpret_cast<char*>(allocate(s, pathSize));
   if (CFStringGetFileSystemRepresentation(path, buffer, pathSize)) {
@@ -130,21 +128,18 @@ const bool Verbose = false;
 
 const unsigned Notified = 1 << 0;
 
-class MySystem: public System {
+class MySystem : public System {
  public:
-  class Thread: public System::Thread {
+  class Thread : public System::Thread {
    public:
-    Thread(System* s, System::Runnable* r):
-      s(s),
-      r(r),
-      next(0),
-      flags(0)
+    Thread(System* s, System::Runnable* r) : s(s), r(r), next(0), flags(0)
     {
       pthread_mutex_init(&mutex, 0);
       pthread_cond_init(&condition, 0);
     }
 
-    virtual void interrupt() {
+    virtual void interrupt()
+    {
       ACQUIRE(mutex);
 
       r->setInterrupted(true);
@@ -158,7 +153,8 @@ class MySystem: public System {
       expect(s, rv == 0);
     }
 
-    virtual bool getAndClearInterrupted() {
+    virtual bool getAndClearInterrupted()
+    {
       ACQUIRE(mutex);
 
       bool interrupted = r->interrupted();
@@ -168,12 +164,14 @@ class MySystem: public System {
       return interrupted;
     }
 
-    virtual void join() {
+    virtual void join()
+    {
       int rv UNUSED = pthread_join(thread, 0);
       expect(s, rv == 0);
     }
 
-    virtual void dispose() {
+    virtual void dispose()
+    {
       pthread_mutex_destroy(&mutex);
       pthread_cond_destroy(&condition);
       ::free(this);
@@ -188,21 +186,25 @@ class MySystem: public System {
     unsigned flags;
   };
 
-  class Mutex: public System::Mutex {
+  class Mutex : public System::Mutex {
    public:
-    Mutex(System* s): s(s) {
-      pthread_mutex_init(&mutex, 0);    
+    Mutex(System* s) : s(s)
+    {
+      pthread_mutex_init(&mutex, 0);
     }
 
-    virtual void acquire() {
+    virtual void acquire()
+    {
       pthread_mutex_lock(&mutex);
     }
 
-    virtual void release() {
+    virtual void release()
+    {
       pthread_mutex_unlock(&mutex);
     }
 
-    virtual void dispose() {
+    virtual void dispose()
+    {
       pthread_mutex_destroy(&mutex);
       ::free(this);
     }
@@ -211,17 +213,19 @@ class MySystem: public System {
     pthread_mutex_t mutex;
   };
 
-  class Monitor: public System::Monitor {
+  class Monitor : public System::Monitor {
    public:
-    Monitor(System* s): s(s), owner_(0), first(0), last(0), depth(0) {
-      pthread_mutex_init(&mutex, 0);    
+    Monitor(System* s) : s(s), owner_(0), first(0), last(0), depth(0)
+    {
+      pthread_mutex_init(&mutex, 0);
     }
 
-    virtual bool tryAcquire(System::Thread* context) {
+    virtual bool tryAcquire(System::Thread* context)
+    {
       Thread* t = static_cast<Thread*>(context);
 
       if (owner_ == t) {
-        ++ depth;
+        ++depth;
         return true;
       } else {
         switch (pthread_mutex_trylock(&mutex)) {
@@ -230,7 +234,7 @@ class MySystem: public System {
 
         case 0:
           owner_ = t;
-          ++ depth;
+          ++depth;
           return true;
 
         default:
@@ -239,21 +243,23 @@ class MySystem: public System {
       }
     }
 
-    virtual void acquire(System::Thread* context) {
+    virtual void acquire(System::Thread* context)
+    {
       Thread* t = static_cast<Thread*>(context);
 
       if (owner_ != t) {
         pthread_mutex_lock(&mutex);
         owner_ = t;
       }
-      ++ depth;
+      ++depth;
     }
 
-    virtual void release(System::Thread* context) {
+    virtual void release(System::Thread* context)
+    {
       Thread* t = static_cast<Thread*>(context);
 
       if (owner_ == t) {
-        if (-- depth == 0) {
+        if (--depth == 0) {
           owner_ = 0;
           pthread_mutex_unlock(&mutex);
         }
@@ -262,7 +268,8 @@ class MySystem: public System {
       }
     }
 
-    void append(Thread* t) {
+    void append(Thread* t)
+    {
 #ifndef NDEBUG
       for (Thread* x = first; x; x = x->next) {
         expect(s, t != x);
@@ -278,7 +285,8 @@ class MySystem: public System {
       }
     }
 
-    void remove(Thread* t) {
+    void remove(Thread* t)
+    {
       Thread* previous = 0;
       for (Thread* current = first; current;) {
         if (t == current) {
@@ -309,7 +317,8 @@ class MySystem: public System {
 #endif
     }
 
-    virtual void wait(System::Thread* context, int64_t time) {
+    virtual void wait(System::Thread* context, int64_t time)
+    {
       wait(context, time, false);
     }
 
@@ -318,7 +327,8 @@ class MySystem: public System {
       return wait(context, time, true);
     }
 
-    bool wait(System::Thread* context, int64_t time, bool clearInterrupted) {
+    bool wait(System::Thread* context, int64_t time, bool clearInterrupted)
+    {
       Thread* t = static_cast<Thread*>(context);
 
       if (owner_ == t) {
@@ -327,8 +337,9 @@ class MySystem: public System {
         bool notified = false;
         unsigned depth = 0;
 
-        { ACQUIRE(t->mutex);
-      
+        {
+          ACQUIRE(t->mutex);
+
           expect(s, (t->flags & Notified) == 0);
 
           interrupted = t->r->interrupted();
@@ -348,10 +359,10 @@ class MySystem: public System {
             // milliseconds) is infinity so as to avoid overflow:
             if (time and time < INT64_C(31536000000000000)) {
               int64_t then = s->now() + time;
-              timespec ts = { static_cast<long>(then / 1000),
-                              static_cast<long>((then % 1000) * 1000 * 1000) };
-              int rv UNUSED = pthread_cond_timedwait
-                (&(t->condition), &(t->mutex), &ts);
+              timespec ts = {static_cast<long>(then / 1000),
+                             static_cast<long>((then % 1000) * 1000 * 1000)};
+              int rv UNUSED
+                  = pthread_cond_timedwait(&(t->condition), &(t->mutex), &ts);
               expect(s, rv == 0 or rv == ETIMEDOUT or rv == EINTR);
             } else {
               int rv UNUSED = pthread_cond_wait(&(t->condition), &(t->mutex));
@@ -369,7 +380,8 @@ class MySystem: public System {
 
         pthread_mutex_lock(&mutex);
 
-        { ACQUIRE(t->mutex);
+        {
+          ACQUIRE(t->mutex);
           t->flags = 0;
         }
 
@@ -394,7 +406,8 @@ class MySystem: public System {
       }
     }
 
-    void doNotify(Thread* t) {
+    void doNotify(Thread* t)
+    {
       ACQUIRE(t->mutex);
 
       t->flags |= Notified;
@@ -402,7 +415,8 @@ class MySystem: public System {
       expect(s, rv == 0);
     }
 
-    virtual void notify(System::Thread* context) {
+    virtual void notify(System::Thread* context)
+    {
       Thread* t = static_cast<Thread*>(context);
 
       if (owner_ == t) {
@@ -421,7 +435,8 @@ class MySystem: public System {
       }
     }
 
-    virtual void notifyAll(System::Thread* context) {
+    virtual void notifyAll(System::Thread* context)
+    {
       Thread* t = static_cast<Thread*>(context);
 
       if (owner_ == t) {
@@ -433,12 +448,14 @@ class MySystem: public System {
         sysAbort(s);
       }
     }
-    
-    virtual System::Thread* owner() {
+
+    virtual System::Thread* owner()
+    {
       return owner_;
     }
 
-    virtual void dispose() {
+    virtual void dispose()
+    {
       expect(s, owner_ == 0);
       pthread_mutex_destroy(&mutex);
       ::free(this);
@@ -452,23 +469,27 @@ class MySystem: public System {
     unsigned depth;
   };
 
-  class Local: public System::Local {
+  class Local : public System::Local {
    public:
-    Local(System* s): s(s) {
+    Local(System* s) : s(s)
+    {
       int r UNUSED = pthread_key_create(&key, 0);
       expect(s, r == 0);
     }
 
-    virtual void* get() {
+    virtual void* get()
+    {
       return pthread_getspecific(key);
     }
 
-    virtual void set(void* p) {
+    virtual void set(void* p)
+    {
       int r UNUSED = pthread_setspecific(key, p);
       expect(s, r == 0);
     }
 
-    virtual void dispose() {
+    virtual void dispose()
+    {
       int r UNUSED = pthread_key_delete(key);
       expect(s, r == 0);
 
@@ -479,23 +500,25 @@ class MySystem: public System {
     pthread_key_t key;
   };
 
-  class Region: public System::Region {
+  class Region : public System::Region {
    public:
-    Region(System* s, uint8_t* start, size_t length):
-      s(s),
-      start_(start),
-      length_(length)
-    { }
+    Region(System* s, uint8_t* start, size_t length)
+        : s(s), start_(start), length_(length)
+    {
+    }
 
-    virtual const uint8_t* start() {
+    virtual const uint8_t* start()
+    {
       return start_;
     }
 
-    virtual size_t length() {
+    virtual size_t length()
+    {
       return length_;
     }
 
-    virtual void dispose() {
+    virtual void dispose()
+    {
       if (start_) {
         munmap(start_, length_);
       }
@@ -507,11 +530,14 @@ class MySystem: public System {
     size_t length_;
   };
 
-  class Directory: public System::Directory {
+  class Directory : public System::Directory {
    public:
-    Directory(System* s, DIR* directory): s(s), directory(directory) { }
+    Directory(System* s, DIR* directory) : s(s), directory(directory)
+    {
+    }
 
-    virtual const char* next() {
+    virtual const char* next()
+    {
       if (directory) {
         dirent* e = readdir(directory);
         if (e) {
@@ -521,7 +547,8 @@ class MySystem: public System {
       return 0;
     }
 
-    virtual void dispose() {
+    virtual void dispose()
+    {
       if (directory) {
         closedir(directory);
       }
@@ -532,40 +559,50 @@ class MySystem: public System {
     DIR* directory;
   };
 
-  class Library: public System::Library {
+  class Library : public System::Library {
    public:
-    Library(System* s, void* p, const char* name, unsigned nameLength,
-            bool isMain):
-      s(s),
-      p(p),
-      mainExecutable(isMain),
-      name_(name),
-      nameLength(nameLength),
-      next_(0)
-    { }
+    Library(System* s,
+            void* p,
+            const char* name,
+            unsigned nameLength,
+            bool isMain)
+        : s(s),
+          p(p),
+          mainExecutable(isMain),
+          name_(name),
+          nameLength(nameLength),
+          next_(0)
+    {
+    }
 
-    virtual void* resolve(const char* function) {
+    virtual void* resolve(const char* function)
+    {
       return dlsym(p, function);
     }
 
-    virtual const char* name() {
+    virtual const char* name()
+    {
       return name_;
     }
 
-    virtual System::Library* next() {
+    virtual System::Library* next()
+    {
       return next_;
     }
 
-    virtual void setNext(System::Library* lib) {
+    virtual void setNext(System::Library* lib)
+    {
       next_ = lib;
     }
 
-    virtual void disposeAll() {
+    virtual void disposeAll()
+    {
       if (Verbose) {
         fprintf(stderr, "close %p\n", p);
       }
 
-      if (not mainExecutable) dlclose(p);
+      if (not mainExecutable)
+        dlclose(p);
 
       if (next_) {
         next_->disposeAll();
@@ -586,9 +623,7 @@ class MySystem: public System {
     System::Library* next_;
   };
 
-  MySystem():
-    threadVisitor(0),
-    visitTarget(0)
+  MySystem() : threadVisitor(0), visitTarget(0)
   {
     expect(this, system == 0);
     system = this;
@@ -601,30 +636,36 @@ class MySystem: public System {
   }
 
   // Returns true on success, false on failure
-  bool unregisterHandler(int index) {
+  bool unregisterHandler(int index)
+  {
     return sigaction(signals[index], oldHandlers + index, 0) == 0;
   }
 
   // Returns true on success, false on failure
-  bool registerHandler(int index) {
+  bool registerHandler(int index)
+  {
     struct sigaction sa;
     memset(&sa, 0, sizeof(struct sigaction));
     sigemptyset(&(sa.sa_mask));
     sa.sa_flags = SA_SIGINFO;
     sa.sa_sigaction = handleSignal;
-  
+
     return sigaction(signals[index], &sa, oldHandlers + index) == 0;
   }
 
-  virtual void* tryAllocate(unsigned sizeInBytes) {
+  virtual void* tryAllocate(unsigned sizeInBytes)
+  {
     return malloc(sizeInBytes);
   }
 
-  virtual void free(const void* p) {
-    if (p) ::free(const_cast<void*>(p));
+  virtual void free(const void* p)
+  {
+    if (p)
+      ::free(const_cast<void*>(p));
   }
 
-  virtual void* tryAllocateExecutable(unsigned sizeInBytes) {
+  virtual void* tryAllocateExecutable(unsigned sizeInBytes)
+  {
 #ifdef MAP_32BIT
     // map to the lower 32 bits of memory when possible so as to avoid
     // expensive relative jumps
@@ -633,34 +674,42 @@ class MySystem: public System {
     const unsigned Extra = 0;
 #endif
 
-    void* p = mmap(0, sizeInBytes, PROT_EXEC | PROT_READ | PROT_WRITE,
-                   MAP_PRIVATE | MAP_ANON | Extra, -1, 0);
+    void* p = mmap(0,
+                   sizeInBytes,
+                   PROT_EXEC | PROT_READ | PROT_WRITE,
+                   MAP_PRIVATE | MAP_ANON | Extra,
+                   -1,
+                   0);
 
     if (p == MAP_FAILED) {
       return 0;
     } else {
-//       fprintf(stderr, "executable from %p to %p\n", p,
-//               static_cast<uint8_t*>(p) + sizeInBytes);
+      //       fprintf(stderr, "executable from %p to %p\n", p,
+      //               static_cast<uint8_t*>(p) + sizeInBytes);
       return static_cast<uint8_t*>(p);
     }
   }
 
-  virtual void freeExecutable(const void* p, unsigned sizeInBytes) {
+  virtual void freeExecutable(const void* p, unsigned sizeInBytes)
+  {
     munmap(const_cast<void*>(p), sizeInBytes);
   }
 
-  virtual bool success(Status s) {
+  virtual bool success(Status s)
+  {
     return s == 0;
   }
 
-  virtual Status attach(Runnable* r) {
+  virtual Status attach(Runnable* r)
+  {
     Thread* t = new (allocate(this, sizeof(Thread))) Thread(this, r);
     t->thread = pthread_self();
     r->attach(t);
     return 0;
   }
 
-  virtual Status start(Runnable* r) {
+  virtual Status start(Runnable* r)
+  {
     Thread* t = new (allocate(this, sizeof(Thread))) Thread(this, r);
     r->attach(t);
     int rv UNUSED = pthread_create(&(t->thread), 0, run, r);
@@ -668,22 +717,26 @@ class MySystem: public System {
     return 0;
   }
 
-  virtual Status make(System::Mutex** m) {
+  virtual Status make(System::Mutex** m)
+  {
     *m = new (allocate(this, sizeof(Mutex))) Mutex(this);
     return 0;
   }
 
-  virtual Status make(System::Monitor** m) {
+  virtual Status make(System::Monitor** m)
+  {
     *m = new (allocate(this, sizeof(Monitor))) Monitor(this);
     return 0;
   }
 
-  virtual Status make(System::Local** l) {
+  virtual Status make(System::Local** l)
+  {
     *l = new (allocate(this, sizeof(Local))) Local(this);
     return 0;
   }
 
-  virtual Status visit(System::Thread* st UNUSED, System::Thread* sTarget,
+  virtual Status visit(System::Thread* st UNUSED,
+                       System::Thread* sTarget,
                        ThreadVisitor* visitor)
   {
     assertT(this, st != sTarget);
@@ -698,14 +751,17 @@ class MySystem: public System {
 
     mach_port_t port = pthread_mach_thread_np(target->thread);
 
-    if (thread_suspend(port)) return -1;
+    if (thread_suspend(port))
+      return -1;
 
     THREAD_STATE_TYPE state;
     mach_msg_type_number_t stateCount = THREAD_STATE_COUNT;
-    kern_return_t rv = thread_get_state
-      (port, THREAD_STATE, reinterpret_cast<thread_state_t>(&state),
-       &stateCount);
-    
+    kern_return_t rv
+        = thread_get_state(port,
+                           THREAD_STATE,
+                           reinterpret_cast<thread_state_t>(&state),
+                           &stateCount);
+
     if (rv == 0) {
       visitor->visit(reinterpret_cast<void*>(THREAD_STATE_IP(state)),
                      reinterpret_cast<void*>(THREAD_STATE_STACK(state)),
@@ -715,12 +771,13 @@ class MySystem: public System {
     thread_resume(port);
 
     return rv ? -1 : 0;
-#else // not __APPLE__
+#else   // not __APPLE__
     Thread* t = static_cast<Thread*>(st);
 
     ACQUIRE_MONITOR(t, visitLock);
 
-    while (threadVisitor) visitLock->wait(t, 0);
+    while (threadVisitor)
+      visitLock->wait(t, 0);
 
     threadVisitor = visitor;
     visitTarget = target;
@@ -729,7 +786,8 @@ class MySystem: public System {
 
     int result;
     if (rv == 0) {
-      while (visitTarget) visitLock->wait(t, 0);
+      while (visitTarget)
+        visitLock->wait(t, 0);
 
       result = 0;
     } else {
@@ -743,10 +801,11 @@ class MySystem: public System {
     system->visitLock->notifyAll(t);
 
     return result;
-#endif // not  __APPLE__
+#endif  // not  __APPLE__
   }
 
-  virtual Status map(System::Region** region, const char* name) {
+  virtual Status map(System::Region** region, const char* name)
+  {
     Status status = 1;
 
     int fd = ::open(name, O_RDONLY);
@@ -757,29 +816,31 @@ class MySystem: public System {
         void* data = mmap(0, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
         if (data) {
           *region = new (allocate(this, sizeof(Region)))
-            Region(this, static_cast<uint8_t*>(data), s.st_size);
+              Region(this, static_cast<uint8_t*>(data), s.st_size);
           status = 0;
         }
       }
       close(fd);
     }
-    
+
     return status;
   }
 
-  virtual Status open(System::Directory** directory, const char* name) {
+  virtual Status open(System::Directory** directory, const char* name)
+  {
     Status status = 1;
-    
+
     DIR* d = opendir(name);
     if (d) {
       *directory = new (allocate(this, sizeof(Directory))) Directory(this, d);
       status = 0;
     }
-    
+
     return status;
   }
 
-  virtual FileType stat(const char* name, unsigned* length) {
+  virtual FileType stat(const char* name, unsigned* length)
+  {
 #ifdef __FreeBSD__
     // Now the hack below causes the error "Dereferencing type-punned
     // pointer will break strict aliasing rules", so another workaround
@@ -816,15 +877,18 @@ class MySystem: public System {
     }
   }
 
-  virtual const char* libraryPrefix() {
+  virtual const char* libraryPrefix()
+  {
     return SO_PREFIX;
   }
 
-  virtual const char* librarySuffix() {
+  virtual const char* librarySuffix()
+  {
     return SO_SUFFIX;
   }
 
-  virtual const char* toAbsolutePath(Allocator* allocator, const char* name) {
+  virtual const char* toAbsolutePath(Allocator* allocator, const char* name)
+  {
     if (name[0] == '/') {
       return copy(allocator, name);
     } else {
@@ -833,8 +897,7 @@ class MySystem: public System {
     }
   }
 
-  virtual Status load(System::Library** lib,
-                      const char* name)
+  virtual Status load(System::Library** lib, const char* name)
   {
     unsigned nameLength = (name ? strlen(name) : 0);
     bool isMain = name == 0;
@@ -842,7 +905,7 @@ class MySystem: public System {
       pathOfExecutable(this, &name, &nameLength);
     }
     void* p = dlopen(name, RTLD_LAZY | RTLD_LOCAL);
- 
+
     if (p) {
       if (Verbose) {
         fprintf(stderr, "open %s as %p\n", name, p);
@@ -860,7 +923,7 @@ class MySystem: public System {
       }
 
       *lib = new (allocate(this, sizeof(Library)))
-        Library(this, p, n, nameLength, isMain);
+          Library(this, p, n, nameLength, isMain);
 
       return 0;
     } else {
@@ -871,34 +934,41 @@ class MySystem: public System {
     }
   }
 
-  virtual char pathSeparator() {
+  virtual char pathSeparator()
+  {
     return ':';
   }
 
-  virtual char fileSeparator() {
+  virtual char fileSeparator()
+  {
     return '/';
   }
 
-  virtual int64_t now() {
-    timeval tv = { 0, 0 };
+  virtual int64_t now()
+  {
+    timeval tv = {0, 0};
     gettimeofday(&tv, 0);
-    return (static_cast<int64_t>(tv.tv_sec) * 1000) +
-      (static_cast<int64_t>(tv.tv_usec) / 1000);
+    return (static_cast<int64_t>(tv.tv_sec) * 1000)
+           + (static_cast<int64_t>(tv.tv_usec) / 1000);
   }
 
-  virtual void yield() {
+  virtual void yield()
+  {
     sched_yield();
   }
 
-  virtual void exit(int code) {
+  virtual void exit(int code)
+  {
     ::exit(code);
   }
 
-  virtual void abort() {
+  virtual void abort()
+  {
     avian::system::crash();
   }
 
-  virtual void dispose() {
+  virtual void dispose()
+  {
     visitLock->dispose();
 
     expect(this, unregisterHandler(InterruptSignalIndex));
@@ -944,14 +1014,13 @@ void handleSignal(int signal, siginfo_t*, void* context)
   }
 }
 
-} // namespace
+}  // namespace
 
 namespace vm {
 
-AVIAN_EXPORT System*
-makeSystem()
+AVIAN_EXPORT System* makeSystem()
 {
   return new (malloc(sizeof(MySystem))) MySystem();
 }
 
-} // namespace vm
+}  // namespace vm
diff --git a/src/system/posix/signal.cpp b/src/system/posix/signal.cpp
index d10051108b..257808ff87 100644
--- a/src/system/posix/signal.cpp
+++ b/src/system/posix/signal.cpp
@@ -40,7 +40,6 @@ namespace system {
 
 namespace posix {
 
-
 const int InvalidSignal = -1;
 const int SegFaultSignal = SIGSEGV;
 const unsigned SegFaultSignalIndex = 0;
@@ -53,11 +52,9 @@ const unsigned AltSegFaultSignalIndex = 1;
 const int DivideByZeroSignal = SIGFPE;
 const unsigned DivideByZeroSignalIndex = 2;
 
-const int signals[]
-    = {SegFaultSignal, AltSegFaultSignal, DivideByZeroSignal};
+const int signals[] = {SegFaultSignal, AltSegFaultSignal, DivideByZeroSignal};
 
 const unsigned SignalCount = 3;
-
 }
 
 struct SignalRegistrar::Data {
@@ -68,7 +65,7 @@ struct SignalRegistrar::Data {
 
   Data()
   {
-    if(instance) {
+    if (instance) {
       crash();
     }
 
@@ -125,8 +122,8 @@ void handleSignal(int signal, siginfo_t*, void* context)
       crash();
     }
 
-    bool jump
-        = SignalRegistrar::Data::instance->handlers[index]->handleSignal(&ip, &frame, &stack, &thread);
+    bool jump = SignalRegistrar::Data::instance->handlers[index]->handleSignal(
+        &ip, &frame, &stack, &thread);
 
     if (jump) {
       // I'd like to use setcontext here (and get rid of the
@@ -150,7 +147,7 @@ void handleSignal(int signal, siginfo_t*, void* context)
   }
 }
 
-} // namespace posix
+}  // namespace posix
 
 NO_RETURN void crash()
 {
@@ -190,9 +187,9 @@ bool SignalRegistrar::Data::registerHandler(Handler* handler, int index)
 
 bool SignalRegistrar::registerHandler(Signal signal, Handler* handler)
 {
-  switch(signal) {
+  switch (signal) {
   case SegFault:
-    if(!data->registerHandler(handler, posix::SegFaultSignalIndex)) {
+    if (!data->registerHandler(handler, posix::SegFaultSignalIndex)) {
       return false;
     }
     if (posix::AltSegFaultSignal != posix::InvalidSignal) {
@@ -209,9 +206,9 @@ bool SignalRegistrar::registerHandler(Signal signal, Handler* handler)
 
 bool SignalRegistrar::unregisterHandler(Signal signal)
 {
-  switch(signal) {
+  switch (signal) {
   case SegFault:
-    if(!data->registerHandler(0, posix::SegFaultSignalIndex)) {
+    if (!data->registerHandler(0, posix::SegFaultSignalIndex)) {
       return false;
     }
     if (posix::AltSegFaultSignal != posix::InvalidSignal) {
diff --git a/src/system/windows.cpp b/src/system/windows.cpp
index 18eff120d3..f6a390e797 100644
--- a/src/system/windows.cpp
+++ b/src/system/windows.cpp
@@ -12,11 +12,11 @@
 #include "windows.h"
 
 #ifdef _MSC_VER
-#  define S_ISREG(x) ((x) & _S_IFREG)
-#  define S_ISDIR(x) ((x) & _S_IFDIR)
-#  define FTIME _ftime_s
+#define S_ISREG(x) ((x)&_S_IFREG)
+#define S_ISDIR(x) ((x)&_S_IFDIR)
+#define FTIME _ftime_s
 #else
-#  define FTIME _ftime
+#define FTIME _ftime
 #endif
 
 #undef max
@@ -36,50 +36,46 @@
   WaitForSingleObjectEx((hHandle), (dwMilliseconds), FALSE)
 
 #define CreateEvent(lpEventAttributes, bManualReset, bInitialState, lpName) \
-  CreateEventEx((lpEventAttributes), (lpName), ((bManualReset)?CREATE_EVENT_MANUAL_RESET:0)|((bInitialState)?CREATE_EVENT_INITIAL_SET:0), EVENT_ALL_ACCESS)
+  CreateEventEx((lpEventAttributes),                                        \
+                (lpName),                                                   \
+                ((bManualReset) ? CREATE_EVENT_MANUAL_RESET : 0)            \
+                | ((bInitialState) ? CREATE_EVENT_INITIAL_SET : 0),         \
+                EVENT_ALL_ACCESS)
 
-#define CreateMutex(lpEventAttributes, bInitialOwner, lpName) \
-  CreateMutexEx((lpEventAttributes), (lpName), (bInitialOwner)?CREATE_MUTEX_INITIAL_OWNER:0, MUTEX_ALL_ACCESS)
+#define CreateMutex(lpEventAttributes, bInitialOwner, lpName)     \
+  CreateMutexEx((lpEventAttributes),                              \
+                (lpName),                                         \
+                (bInitialOwner) ? CREATE_MUTEX_INITIAL_OWNER : 0, \
+                MUTEX_ALL_ACCESS)
 
 #include "thread-emulation.h"
 
 #endif
 
-#if defined(WINAPI_PARTITION_PHONE) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE)
-// Headers in Windows Phone 8 DevKit contain severe error, so let's define needed functions on our own
-extern "C"
-{
+#if defined(WINAPI_PARTITION_PHONE) \
+    && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE)
+// Headers in Windows Phone 8 DevKit contain severe error, so let's define
+// needed functions on our own
+extern "C" {
 WINBASEAPI
-_Ret_maybenull_
-HANDLE
-WINAPI
-CreateFileMappingFromApp(
-    _In_ HANDLE hFile,
-    _In_opt_ PSECURITY_ATTRIBUTES SecurityAttributes,
-    _In_ ULONG PageProtection,
-    _In_ ULONG64 MaximumSize,
-    _In_opt_ PCWSTR Name
-    );
+_Ret_maybenull_ HANDLE WINAPI
+    CreateFileMappingFromApp(_In_ HANDLE hFile,
+                             _In_opt_ PSECURITY_ATTRIBUTES SecurityAttributes,
+                             _In_ ULONG PageProtection,
+                             _In_ ULONG64 MaximumSize,
+                             _In_opt_ PCWSTR Name);
 
 WINBASEAPI
-_Ret_maybenull_  __out_data_source(FILE)
-PVOID
-WINAPI
-MapViewOfFileFromApp(
-    _In_ HANDLE hFileMappingObject,
-    _In_ ULONG DesiredAccess,
-    _In_ ULONG64 FileOffset,
-    _In_ SIZE_T NumberOfBytesToMap
-    );
+_Ret_maybenull_ __out_data_source(FILE) PVOID WINAPI
+    MapViewOfFileFromApp(_In_ HANDLE hFileMappingObject,
+                         _In_ ULONG DesiredAccess,
+                         _In_ ULONG64 FileOffset,
+                         _In_ SIZE_T NumberOfBytesToMap);
 
 WINBASEAPI
-BOOL
-WINAPI
-UnmapViewOfFile(
-    _In_ LPCVOID lpBaseAddress
-    );
+BOOL WINAPI UnmapViewOfFile(_In_ LPCVOID lpBaseAddress);
 }
-#endif // WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE)
+#endif  // WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE)
 
 #else
 
@@ -93,7 +89,7 @@ UnmapViewOfFile(
 
 #endif
 
-#define ACQUIRE(s, x) MutexResource MAKE_NAME(mutexResource_) (s, x)
+#define ACQUIRE(s, x) MutexResource MAKE_NAME(mutexResource_)(s, x)
 
 using namespace vm;
 
@@ -101,26 +97,27 @@ namespace {
 
 class MutexResource {
  public:
-  MutexResource(System* s, HANDLE m): s(s), m(m) {
+  MutexResource(System* s, HANDLE m) : s(s), m(m)
+  {
     int r UNUSED = WaitForSingleObject(m, INFINITE);
     assertT(s, r == WAIT_OBJECT_0);
   }
 
-  ~MutexResource() {
+  ~MutexResource()
+  {
     bool success UNUSED = ReleaseMutex(m);
     assertT(s, success);
   }
 
  private:
-  System* s; 
+  System* s;
   HANDLE m;
 };
 
 class MySystem;
 MySystem* system;
 
-DWORD WINAPI
-run(void* r)
+DWORD WINAPI run(void* r)
 {
   static_cast<System::Runnable*>(r)->run();
   return 0;
@@ -131,15 +128,11 @@ const bool Verbose = false;
 const unsigned Waiting = 1 << 0;
 const unsigned Notified = 1 << 1;
 
-class MySystem: public System {
+class MySystem : public System {
  public:
-  class Thread: public System::Thread {
+  class Thread : public System::Thread {
    public:
-    Thread(System* s, System::Runnable* r):
-      s(s),
-      r(r),
-      next(0),
-      flags(0)
+    Thread(System* s, System::Runnable* r) : s(s), r(r), next(0), flags(0)
     {
       mutex = CreateMutex(0, false, 0);
       assertT(s, mutex);
@@ -148,7 +141,8 @@ class MySystem: public System {
       assertT(s, event);
     }
 
-    virtual void interrupt() {
+    virtual void interrupt()
+    {
       ACQUIRE(s, mutex);
 
       r->setInterrupted(true);
@@ -159,7 +153,8 @@ class MySystem: public System {
       }
     }
 
-    virtual bool getAndClearInterrupted() {
+    virtual bool getAndClearInterrupted()
+    {
       ACQUIRE(s, mutex);
 
       bool interrupted = r->interrupted();
@@ -169,12 +164,14 @@ class MySystem: public System {
       return interrupted;
     }
 
-    virtual void join() {
+    virtual void join()
+    {
       int r UNUSED = WaitForSingleObject(thread, INFINITE);
       assertT(s, r == WAIT_OBJECT_0);
     }
 
-    virtual void dispose() {
+    virtual void dispose()
+    {
       CloseHandle(event);
       CloseHandle(mutex);
       CloseHandle(thread);
@@ -190,24 +187,28 @@ class MySystem: public System {
     unsigned flags;
   };
 
-  class Mutex: public System::Mutex {
+  class Mutex : public System::Mutex {
    public:
-    Mutex(System* s): s(s) {
+    Mutex(System* s) : s(s)
+    {
       mutex = CreateMutex(0, false, 0);
       assertT(s, mutex);
     }
 
-    virtual void acquire() {
+    virtual void acquire()
+    {
       int r UNUSED = WaitForSingleObject(mutex, INFINITE);
       assertT(s, r == WAIT_OBJECT_0);
     }
 
-    virtual void release() {
+    virtual void release()
+    {
       bool success UNUSED = ReleaseMutex(mutex);
       assertT(s, success);
     }
 
-    virtual void dispose() {
+    virtual void dispose()
+    {
       CloseHandle(mutex);
       ::free(this);
     }
@@ -216,19 +217,21 @@ class MySystem: public System {
     HANDLE mutex;
   };
 
-  class Monitor: public System::Monitor {
+  class Monitor : public System::Monitor {
    public:
-    Monitor(System* s): s(s), owner_(0), first(0), last(0), depth(0) {
+    Monitor(System* s) : s(s), owner_(0), first(0), last(0), depth(0)
+    {
       mutex = CreateMutex(0, false, 0);
       assertT(s, mutex);
     }
 
-    virtual bool tryAcquire(System::Thread* context) {
+    virtual bool tryAcquire(System::Thread* context)
+    {
       Thread* t = static_cast<Thread*>(context);
       assertT(s, t);
 
       if (owner_ == t) {
-        ++ depth;
+        ++depth;
         return true;
       } else {
         switch (WaitForSingleObject(mutex, 0)) {
@@ -237,7 +240,7 @@ class MySystem: public System {
 
         case WAIT_OBJECT_0:
           owner_ = t;
-          ++ depth;
+          ++depth;
           return true;
 
         default:
@@ -246,7 +249,8 @@ class MySystem: public System {
       }
     }
 
-    virtual void acquire(System::Thread* context) {
+    virtual void acquire(System::Thread* context)
+    {
       Thread* t = static_cast<Thread*>(context);
       assertT(s, t);
 
@@ -255,15 +259,16 @@ class MySystem: public System {
         assertT(s, r == WAIT_OBJECT_0);
         owner_ = t;
       }
-      ++ depth;
+      ++depth;
     }
 
-    virtual void release(System::Thread* context) {
+    virtual void release(System::Thread* context)
+    {
       Thread* t = static_cast<Thread*>(context);
       assertT(s, t);
 
       if (owner_ == t) {
-        if (-- depth == 0) {
+        if (--depth == 0) {
           owner_ = 0;
           bool success UNUSED = ReleaseMutex(mutex);
           assertT(s, success);
@@ -273,7 +278,8 @@ class MySystem: public System {
       }
     }
 
-    void append(Thread* t) {
+    void append(Thread* t)
+    {
 #ifndef NDEBUG
       for (Thread* x = first; x; x = x->next) {
         expect(s, t != x);
@@ -288,7 +294,8 @@ class MySystem: public System {
       }
     }
 
-    void remove(Thread* t) {
+    void remove(Thread* t)
+    {
       Thread* previous = 0;
       for (Thread* current = first; current;) {
         if (t == current) {
@@ -318,7 +325,8 @@ class MySystem: public System {
 #endif
     }
 
-    virtual void wait(System::Thread* context, int64_t time) {
+    virtual void wait(System::Thread* context, int64_t time)
+    {
       wait(context, time, false);
     }
 
@@ -327,7 +335,8 @@ class MySystem: public System {
       return wait(context, time, true);
     }
 
-    bool wait(System::Thread* context, int64_t time, bool clearInterrupted) {
+    bool wait(System::Thread* context, int64_t time, bool clearInterrupted)
+    {
       Thread* t = static_cast<Thread*>(context);
       assertT(s, t);
 
@@ -339,7 +348,8 @@ class MySystem: public System {
 
         int r UNUSED;
 
-        { ACQUIRE(s, t->mutex);
+        {
+          ACQUIRE(s, t->mutex);
 
           expect(s, (t->flags & Notified) == 0);
 
@@ -384,7 +394,8 @@ class MySystem: public System {
         r = WaitForSingleObject(mutex, INFINITE);
         assertT(s, r == WAIT_OBJECT_0);
 
-        { ACQUIRE(s, t->mutex);
+        {
+          ACQUIRE(s, t->mutex);
           t->flags = 0;
         }
 
@@ -409,7 +420,8 @@ class MySystem: public System {
       }
     }
 
-    void doNotify(Thread* t) {
+    void doNotify(Thread* t)
+    {
       ACQUIRE(s, t->mutex);
 
       t->flags |= Notified;
@@ -418,7 +430,8 @@ class MySystem: public System {
       assertT(s, success);
     }
 
-    virtual void notify(System::Thread* context) {
+    virtual void notify(System::Thread* context)
+    {
       Thread* t = static_cast<Thread*>(context);
       assertT(s, t);
 
@@ -438,7 +451,8 @@ class MySystem: public System {
       }
     }
 
-    virtual void notifyAll(System::Thread* context) {
+    virtual void notifyAll(System::Thread* context)
+    {
       Thread* t = static_cast<Thread*>(context);
       assertT(s, t);
 
@@ -451,12 +465,14 @@ class MySystem: public System {
         sysAbort(s);
       }
     }
-    
-    virtual System::Thread* owner() {
+
+    virtual System::Thread* owner()
+    {
       return owner_;
     }
 
-    virtual void dispose() {
+    virtual void dispose()
+    {
       assertT(s, owner_ == 0);
       CloseHandle(mutex);
       ::free(this);
@@ -470,23 +486,27 @@ class MySystem: public System {
     unsigned depth;
   };
 
-  class Local: public System::Local {
+  class Local : public System::Local {
    public:
-    Local(System* s): s(s) {
+    Local(System* s) : s(s)
+    {
       key = TlsAlloc();
       assertT(s, key != TLS_OUT_OF_INDEXES);
     }
 
-    virtual void* get() {
+    virtual void* get()
+    {
       return TlsGetValue(key);
     }
 
-    virtual void set(void* p) {
+    virtual void set(void* p)
+    {
       bool r UNUSED = TlsSetValue(key, p);
       assertT(s, r);
     }
 
-    virtual void dispose() {
+    virtual void dispose()
+    {
       bool r UNUSED = TlsFree(key);
       assertT(s, r);
 
@@ -497,30 +517,40 @@ class MySystem: public System {
     unsigned key;
   };
 
-  class Region: public System::Region {
+  class Region : public System::Region {
    public:
-    Region(System* system, uint8_t* start, size_t length, HANDLE mapping,
-           HANDLE file):
-      system(system),
-      start_(start),
-      length_(length),
-      mapping(mapping),
-      file(file)
-    { }
+    Region(System* system,
+           uint8_t* start,
+           size_t length,
+           HANDLE mapping,
+           HANDLE file)
+        : system(system),
+          start_(start),
+          length_(length),
+          mapping(mapping),
+          file(file)
+    {
+    }
 
-    virtual const uint8_t* start() {
+    virtual const uint8_t* start()
+    {
       return start_;
     }
 
-    virtual size_t length() {
+    virtual size_t length()
+    {
       return length_;
     }
 
-    virtual void dispose() {
+    virtual void dispose()
+    {
       if (start_) {
-        if (start_) UnmapViewOfFile(start_);
-        if (mapping) CloseHandle(mapping);
-        if (file) CloseHandle(file);
+        if (start_)
+          UnmapViewOfFile(start_);
+        if (mapping)
+          CloseHandle(mapping);
+        if (file)
+          CloseHandle(file);
       }
       system->free(this);
     }
@@ -532,11 +562,14 @@ class MySystem: public System {
     HANDLE file;
   };
 
-  class Directory: public System::Directory {
+  class Directory : public System::Directory {
    public:
-    Directory(System* s): s(s), handle(0), findNext(false) { }
+    Directory(System* s) : s(s), handle(0), findNext(false)
+    {
+    }
 
-    virtual const char* next() {
+    virtual const char* next()
+    {
       if (handle and handle != INVALID_HANDLE_VALUE) {
         if (findNext) {
           if (FindNextFile(handle, &data)) {
@@ -550,7 +583,8 @@ class MySystem: public System {
       return 0;
     }
 
-    virtual void dispose() {
+    virtual void dispose()
+    {
       if (handle and handle != INVALID_HANDLE_VALUE) {
         FindClose(handle);
       }
@@ -563,37 +597,41 @@ class MySystem: public System {
     bool findNext;
   };
 
-  class Library: public System::Library {
+  class Library : public System::Library {
    public:
-    Library(System* s, HMODULE handle, const char* name):
-      s(s),
-      handle(handle),
-      name_(name),
-      next_(0)
-    { }
+    Library(System* s, HMODULE handle, const char* name)
+        : s(s), handle(handle), name_(name), next_(0)
+    {
+    }
 
-    virtual void* resolve(const char* function) {
+    virtual void* resolve(const char* function)
+    {
       void* address;
       FARPROC p = GetProcAddress(handle, function);
       memcpy(&address, &p, BytesPerWord);
       return address;
     }
 
-    virtual const char* name() {
+    virtual const char* name()
+    {
       return name_;
     }
 
-    virtual System::Library* next() {
+    virtual System::Library* next()
+    {
       return next_;
     }
 
-    virtual void setNext(System::Library* lib) {
+    virtual void setNext(System::Library* lib)
+    {
       next_ = lib;
     }
 
-    virtual void disposeAll() {
+    virtual void disposeAll()
+    {
       if (Verbose) {
-        fprintf(stderr, "close %p\n", handle); fflush(stderr);
+        fprintf(stderr, "close %p\n", handle);
+        fflush(stderr);
       }
 
       if (name_) {
@@ -626,41 +664,53 @@ class MySystem: public System {
     assertT(this, mutex);
   }
 
-  virtual void* tryAllocate(unsigned sizeInBytes) {
+  virtual void* tryAllocate(unsigned sizeInBytes)
+  {
     return malloc(sizeInBytes);
   }
 
-  virtual void free(const void* p) {
-    if (p) ::free(const_cast<void*>(p));
+  virtual void free(const void* p)
+  {
+    if (p)
+      ::free(const_cast<void*>(p));
   }
 
-  #if !defined(AVIAN_AOT_ONLY)
-  virtual void* tryAllocateExecutable(unsigned sizeInBytes) {
-    return VirtualAlloc
-      (0, sizeInBytes, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
+#if !defined(AVIAN_AOT_ONLY)
+  virtual void* tryAllocateExecutable(unsigned sizeInBytes)
+  {
+    return VirtualAlloc(
+        0, sizeInBytes, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
   }
 
-  virtual void freeExecutable(const void* p, unsigned) {
+  virtual void freeExecutable(const void* p, unsigned)
+  {
     int r UNUSED = VirtualFree(const_cast<void*>(p), 0, MEM_RELEASE);
     assertT(this, r);
   }
-  #endif
+#endif
 
-  virtual bool success(Status s) {
+  virtual bool success(Status s)
+  {
     return s == 0;
   }
 
-  virtual Status attach(Runnable* r) {
+  virtual Status attach(Runnable* r)
+  {
     Thread* t = new (allocate(this, sizeof(Thread))) Thread(this, r);
-    bool success UNUSED = DuplicateHandle
-      (GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(),
-       &(t->thread), 0, false, DUPLICATE_SAME_ACCESS);
+    bool success UNUSED = DuplicateHandle(GetCurrentProcess(),
+                                          GetCurrentThread(),
+                                          GetCurrentProcess(),
+                                          &(t->thread),
+                                          0,
+                                          false,
+                                          DUPLICATE_SAME_ACCESS);
     assertT(this, success);
     r->attach(t);
     return 0;
   }
 
-  virtual Status start(Runnable* r) {
+  virtual Status start(Runnable* r)
+  {
     Thread* t = new (allocate(this, sizeof(Thread))) Thread(this, r);
     r->attach(t);
     DWORD id;
@@ -669,22 +719,26 @@ class MySystem: public System {
     return 0;
   }
 
-  virtual Status make(System::Mutex** m) {
+  virtual Status make(System::Mutex** m)
+  {
     *m = new (allocate(this, sizeof(Mutex))) Mutex(this);
     return 0;
   }
 
-  virtual Status make(System::Monitor** m) {
+  virtual Status make(System::Monitor** m)
+  {
     *m = new (allocate(this, sizeof(Monitor))) Monitor(this);
     return 0;
   }
 
-  virtual Status make(System::Local** l) {
+  virtual Status make(System::Local** l)
+  {
     *l = new (allocate(this, sizeof(Local))) Local(this);
     return 0;
   }
 
-  virtual Status visit(System::Thread* st UNUSED, System::Thread* sTarget,
+  virtual Status visit(System::Thread* st UNUSED,
+                       System::Thread* sTarget,
                        ThreadVisitor* visitor)
   {
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
@@ -703,15 +757,15 @@ class MySystem: public System {
       rv = GetThreadContext(target->thread, &context);
 
       if (rv) {
-#  ifdef ARCH_x86_32
+#ifdef ARCH_x86_32
         visitor->visit(reinterpret_cast<void*>(context.Eip),
                        reinterpret_cast<void*>(context.Esp),
                        reinterpret_cast<void*>(context.Ebp));
-#  elif defined ARCH_x86_64
+#elif defined ARCH_x86_64
         visitor->visit(reinterpret_cast<void*>(context.Rip),
                        reinterpret_cast<void*>(context.Rsp),
                        reinterpret_cast<void*>(context.Rbp));
-#  endif
+#endif
         success = true;
       }
 
@@ -721,22 +775,33 @@ class MySystem: public System {
 
     return (success ? 0 : 1);
 #else
-    #pragma message("TODO: http://msdn.microsoft.com/en-us/library/windowsphone/develop/system.windows.application.unhandledexception(v=vs.105).aspx")
+#pragma message( \
+    "TODO: http://msdn.microsoft.com/en-us/library/windowsphone/develop/system.windows.application.unhandledexception(v=vs.105).aspx")
     return false;
 #endif
   }
 
-  virtual Status map(System::Region** region, const char* name) {
+  virtual Status map(System::Region** region, const char* name)
+  {
     Status status = 1;
     size_t nameLen = strlen(name) * 2;
     RUNTIME_ARRAY(wchar_t, wideName, nameLen + 1);
-    MultiByteToWideChar(CP_UTF8, 0, name, -1, RUNTIME_ARRAY_BODY(wideName), nameLen + 1);
+    MultiByteToWideChar(
+        CP_UTF8, 0, name, -1, RUNTIME_ARRAY_BODY(wideName), nameLen + 1);
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-    HANDLE file = CreateFileW(RUNTIME_ARRAY_BODY(wideName), FILE_READ_DATA, FILE_SHARE_READ, 0,
-    OPEN_EXISTING, 0, 0);
+    HANDLE file = CreateFileW(RUNTIME_ARRAY_BODY(wideName),
+                              FILE_READ_DATA,
+                              FILE_SHARE_READ,
+                              0,
+                              OPEN_EXISTING,
+                              0,
+                              0);
 #else
-    HANDLE file = CreateFile2(RUNTIME_ARRAY_BODY(wideName), GENERIC_READ, FILE_SHARE_READ,
-                             OPEN_EXISTING, 0);
+    HANDLE file = CreateFile2(RUNTIME_ARRAY_BODY(wideName),
+                              GENERIC_READ,
+                              FILE_SHARE_READ,
+                              OPEN_EXISTING,
+                              0);
 #endif
     if (file != INVALID_HANDLE_VALUE) {
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
@@ -744,14 +809,16 @@ class MySystem: public System {
 #else
       FILE_STANDARD_INFO info;
       unsigned size = INVALID_FILE_SIZE;
-      if(GetFileInformationByHandleEx(file,  FileStandardInfo, &info, sizeof(info)))
+      if (GetFileInformationByHandleEx(
+              file, FileStandardInfo, &info, sizeof(info)))
         size = info.EndOfFile.QuadPart;
 #endif
       if (size != INVALID_FILE_SIZE) {
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
         HANDLE mapping = CreateFileMapping(file, 0, PAGE_READONLY, 0, size, 0);
 #else
-        HANDLE mapping = CreateFileMappingFromApp(file, 0, PAGE_READONLY, size, 0);
+        HANDLE mapping
+            = CreateFileMappingFromApp(file, 0, PAGE_READONLY, size, 0);
 #endif
         if (mapping) {
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
@@ -761,8 +828,8 @@ class MySystem: public System {
 #endif
           if (data) {
             *region = new (allocate(this, sizeof(Region)))
-              Region(this, static_cast<uint8_t*>(data), size, file, mapping);
-            status = 0;        
+                Region(this, static_cast<uint8_t*>(data), size, file, mapping);
+            status = 0;
           }
 
           if (status) {
@@ -775,11 +842,12 @@ class MySystem: public System {
         CloseHandle(file);
       }
     }
-    
+
     return status;
   }
 
-  virtual Status open(System::Directory** directory, const char* name) {
+  virtual Status open(System::Directory** directory, const char* name)
+  {
     Status status = 1;
 
     unsigned length = strlen(name);
@@ -792,7 +860,12 @@ class MySystem: public System {
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
     d->handle = FindFirstFile(RUNTIME_ARRAY_BODY(buffer), &(d->data));
 #else
-    d->handle = FindFirstFileEx(RUNTIME_ARRAY_BODY(buffer), FindExInfoStandard, &(d->data), FindExSearchNameMatch, 0, 0);
+    d->handle = FindFirstFileEx(RUNTIME_ARRAY_BODY(buffer),
+                                FindExInfoStandard,
+                                &(d->data),
+                                FindExSearchNameMatch,
+                                0,
+                                0);
 #endif
     if (d->handle == INVALID_HANDLE_VALUE) {
       d->dispose();
@@ -800,23 +873,24 @@ class MySystem: public System {
       *directory = d;
       status = 0;
     }
-    
+
     return status;
   }
 
-  virtual FileType stat(const char* name, unsigned* length) {
+  virtual FileType stat(const char* name, unsigned* length)
+  {
     size_t nameLen = strlen(name) * 2;
     RUNTIME_ARRAY(wchar_t, wideName, nameLen + 1);
-    MultiByteToWideChar(CP_UTF8, 0, name, -1, RUNTIME_ARRAY_BODY(wideName), nameLen + 1);
+    MultiByteToWideChar(
+        CP_UTF8, 0, name, -1, RUNTIME_ARRAY_BODY(wideName), nameLen + 1);
     WIN32_FILE_ATTRIBUTE_DATA data;
-    if (GetFileAttributesExW
-        (RUNTIME_ARRAY_BODY(wideName), GetFileExInfoStandard, &data))
-    {
+    if (GetFileAttributesExW(
+            RUNTIME_ARRAY_BODY(wideName), GetFileExInfoStandard, &data)) {
       if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
         return TypeDirectory;
       } else {
         *length = (data.nFileSizeHigh * static_cast<int64_t>(MAXDWORD + 1))
-          + data.nFileSizeLow;
+                  + data.nFileSizeLow;
         return TypeFile;
       }
     } else {
@@ -824,11 +898,13 @@ class MySystem: public System {
     }
   }
 
-  virtual const char* libraryPrefix() {
+  virtual const char* libraryPrefix()
+  {
     return SO_PREFIX;
   }
 
-  virtual const char* librarySuffix() {
+  virtual const char* librarySuffix()
+  {
     return SO_SUFFIX;
   }
 
@@ -836,11 +912,9 @@ class MySystem: public System {
                                      const char* name)
   {
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-    if (strncmp(name, "//", 2) == 0
-        or strncmp(name, "\\\\", 2) == 0
+    if (strncmp(name, "//", 2) == 0 or strncmp(name, "\\\\", 2) == 0
         or strncmp(name + 1, ":/", 2) == 0
-        or strncmp(name + 1, ":\\", 2) == 0)
-    {
+        or strncmp(name + 1, ":\\", 2) == 0) {
       return copy(allocator, name);
     } else {
       TCHAR buffer[MAX_PATH];
@@ -848,20 +922,21 @@ class MySystem: public System {
       return append(allocator, buffer, "\\", name);
     }
 #else
-    #pragma message("TODO:http://lunarfrog.com/blog/2012/05/21/winrt-folders-access/ Windows.ApplicationModel.Package.Current.InstalledLocation")
+#pragma message( \
+    "TODO:http://lunarfrog.com/blog/2012/05/21/winrt-folders-access/ Windows.ApplicationModel.Package.Current.InstalledLocation")
     return copy(allocator, name);
 #endif
   }
 
-  virtual Status load(System::Library** lib,
-                      const char* name)
+  virtual Status load(System::Library** lib, const char* name)
   {
     HMODULE handle;
     unsigned nameLength = (name ? strlen(name) : 0);
     if (name) {
       size_t nameLen = nameLength * 2;
       RUNTIME_ARRAY(wchar_t, wideName, nameLen + 1);
-      MultiByteToWideChar(CP_UTF8, 0, name, -1, RUNTIME_ARRAY_BODY(wideName), nameLen + 1);
+      MultiByteToWideChar(
+          CP_UTF8, 0, name, -1, RUNTIME_ARRAY_BODY(wideName), nameLen + 1);
 
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
       handle = LoadLibraryW(RUNTIME_ARRAY_BODY(wideName));
@@ -872,14 +947,16 @@ class MySystem: public System {
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
       handle = GetModuleHandle(0);
 #else
-      // Most of WinRT/WP8 applications can not host native object files inside main executable
+      // Most of WinRT/WP8 applications can not host native object files inside
+      // main executable
       assertT(this, false);
 #endif
     }
- 
+
     if (handle) {
       if (Verbose) {
-        fprintf(stderr, "open %s as %p\n", name, handle); fflush(stderr);
+        fprintf(stderr, "open %s as %p\n", name, handle);
+        fflush(stderr);
       }
 
       char* n;
@@ -903,15 +980,18 @@ class MySystem: public System {
     }
   }
 
-  virtual char pathSeparator() {
+  virtual char pathSeparator()
+  {
     return ';';
   }
 
-  virtual char fileSeparator() {
+  virtual char fileSeparator()
+  {
     return '\\';
   }
 
-  virtual int64_t now() {
+  virtual int64_t now()
+  {
     // We used to use _ftime here, but that only gives us 1-second
     // resolution on Windows 7.  _ftime_s might work better, but MinGW
     // doesn't have it as of this writing.  So we use this mess instead:
@@ -921,7 +1001,8 @@ class MySystem: public System {
              | time.dwLowDateTime) / 10000) - 11644473600000LL;
   }
 
-  virtual void yield() {
+  virtual void yield()
+  {
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
     SwitchToThread();
 #else
@@ -929,15 +1010,18 @@ class MySystem: public System {
 #endif
   }
 
-  virtual void exit(int code) {
+  virtual void exit(int code)
+  {
     ::exit(code);
   }
 
-  virtual void abort() {
+  virtual void abort()
+  {
     avian::system::crash();
   }
 
-  virtual void dispose() {
+  virtual void dispose()
+  {
     system = 0;
     CloseHandle(mutex);
     ::free(this);
@@ -946,14 +1030,13 @@ class MySystem: public System {
   HANDLE mutex;
 };
 
-} // namespace
+}  // namespace
 
 namespace vm {
 
-AVIAN_EXPORT System*
-makeSystem()
+AVIAN_EXPORT System* makeSystem()
 {
   return new (malloc(sizeof(MySystem))) MySystem();
 }
 
-} // namespace vm
+}  // namespace vm
diff --git a/src/system/windows/signal.cpp b/src/system/windows/signal.cpp
index 2b16aee7d0..34cd5e27a8 100644
--- a/src/system/windows/signal.cpp
+++ b/src/system/windows/signal.cpp
@@ -49,9 +49,10 @@ struct SignalRegistrar::Data {
   LPTOP_LEVEL_EXCEPTION_FILTER oldHandler;
 #endif
 
-  Data() : crashDumpDirectory(0),
+  Data()
+      : crashDumpDirectory(0),
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-    oldHandler(0)
+        oldHandler(0)
 #endif
   {
     if (instance) {
@@ -68,9 +69,11 @@ struct SignalRegistrar::Data {
 
   bool registerHandler(Handler* handler, int index);
 
-  bool findHandler() {
+  bool findHandler()
+  {
     for (unsigned i = 0; i < windows::HandlerCount; ++i) {
-      if (handlers[i]) return true;
+      if (handlers[i])
+        return true;
     }
     return false;
   }
@@ -95,21 +98,16 @@ struct MINIDUMP_EXCEPTION_INFORMATION {
 struct MINIDUMP_USER_STREAM_INFORMATION;
 struct MINIDUMP_CALLBACK_INFORMATION;
 
-enum MINIDUMP_TYPE {
-  MiniDumpNormal = 0,
-  MiniDumpWithFullMemory = 2
-};
+enum MINIDUMP_TYPE { MiniDumpNormal = 0, MiniDumpWithFullMemory = 2 };
 
-typedef BOOL (*MiniDumpWriteDumpType)(HANDLE processHandle,
-                                      DWORD processId,
-                                      HANDLE file,
-                                      MINIDUMP_TYPE type,
-                                      const MINIDUMP_EXCEPTION_INFORMATION
-                                      * exception,
-                                      const MINIDUMP_USER_STREAM_INFORMATION
-                                      * userStream,
-                                      const MINIDUMP_CALLBACK_INFORMATION
-                                      * callback);
+typedef BOOL (*MiniDumpWriteDumpType)(
+    HANDLE processHandle,
+    DWORD processId,
+    HANDLE file,
+    MINIDUMP_TYPE type,
+    const MINIDUMP_EXCEPTION_INFORMATION* exception,
+    const MINIDUMP_USER_STREAM_INFORMATION* userStream,
+    const MINIDUMP_CALLBACK_INFORMATION* callback);
 
 #endif
 
@@ -118,8 +116,9 @@ void dump(LPEXCEPTION_POINTERS e, const char* directory)
   HINSTANCE dbghelp = LoadLibrary("dbghelp.dll");
 
   if (dbghelp) {
-    MiniDumpWriteDumpType MiniDumpWriteDump = reinterpret_cast
-        <MiniDumpWriteDumpType>(GetProcAddress(dbghelp, "MiniDumpWriteDump"));
+    MiniDumpWriteDumpType MiniDumpWriteDump
+        = reinterpret_cast<MiniDumpWriteDumpType>(
+            GetProcAddress(dbghelp, "MiniDumpWriteDump"));
 
     if (MiniDumpWriteDump) {
       char name[MAX_PATH];
@@ -129,8 +128,8 @@ void dump(LPEXCEPTION_POINTERS e, const char* directory)
                    MAX_PATH,
                    "%s\\crash-%" LLD ".mdmp",
                    directory,
-                   (static_cast<int64_t>(tb.time) * 1000) + static_cast
-                   <int64_t>(tb.millitm));
+                   (static_cast<int64_t>(tb.time) * 1000)
+                   + static_cast<int64_t>(tb.millitm));
 
       HANDLE file
           = CreateFile(name, FILE_WRITE_DATA, 0, 0, CREATE_ALWAYS, 0, 0);
@@ -206,10 +205,12 @@ LONG CALLBACK handleException(LPEXCEPTION_POINTERS e)
 {
   SignalRegistrar::Handler* handler = 0;
   if (e->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION) {
-    handler = SignalRegistrar::Data::instance->handlers[SignalRegistrar::SegFault];
+    handler
+        = SignalRegistrar::Data::instance->handlers[SignalRegistrar::SegFault];
   } else if (e->ExceptionRecord->ExceptionCode
              == EXCEPTION_INT_DIVIDE_BY_ZERO) {
-    handler = SignalRegistrar::Data::instance->handlers[SignalRegistrar::DivideByZero];
+    handler = SignalRegistrar::Data::instance
+                  ->handlers[SignalRegistrar::DivideByZero];
   }
 
   if (handler) {
@@ -278,7 +279,7 @@ SignalRegistrar::~SignalRegistrar()
 
 bool SignalRegistrar::Data::registerHandler(Handler* handler, int index)
 {
-  if(index != SegFault && index != DivideByZero) {
+  if (index != SegFault && index != DivideByZero) {
     crash();
   }
 
diff --git a/src/tools/binary-to-object/main.cpp b/src/tools/binary-to-object/main.cpp
index 3e29b319cd..4cd9ff5879 100644
--- a/src/tools/binary-to-object/main.cpp
+++ b/src/tools/binary-to-object/main.cpp
@@ -24,48 +24,59 @@
 
 #include <avian/tools/object-writer/tools.h>
 
-extern "C"
-void __cxa_pure_virtual() {
+extern "C" void __cxa_pure_virtual()
+{
   abort();
 }
 
-void* operator new(size_t size) {
+void* operator new(size_t size)
+{
   return malloc(size);
 }
 
-void operator delete(void*) { abort(); }
+void operator delete(void*)
+{
+  abort();
+}
 
 namespace {
 
 using namespace avian::tools;
 using namespace avian::util;
 
-bool
-writeObject(uint8_t* data, size_t size, OutputStream* out, const char* startName,
-            const char* endName, const char* format,
-            const char* architecture, unsigned alignment, bool writable,
-            bool executable)
+bool writeObject(uint8_t* data,
+                 size_t size,
+                 OutputStream* out,
+                 const char* startName,
+                 const char* endName,
+                 const char* format,
+                 const char* architecture,
+                 unsigned alignment,
+                 bool writable,
+                 bool executable)
 {
-  Platform* platform = Platform::getPlatform(PlatformInfo(PlatformInfo::formatFromString(format), PlatformInfo::archFromString(architecture)));
+  Platform* platform = Platform::getPlatform(
+      PlatformInfo(PlatformInfo::formatFromString(format),
+                   PlatformInfo::archFromString(architecture)));
 
-  if(!platform) {
+  if (!platform) {
     fprintf(stderr, "unsupported platform: %s/%s\n", format, architecture);
     return false;
   }
 
-  SymbolInfo symbols[] = {
-    SymbolInfo(0, startName),
-    SymbolInfo(size, endName)
-  };
+  SymbolInfo symbols[] = {SymbolInfo(0, startName), SymbolInfo(size, endName)};
 
-  unsigned accessFlags = (writable ? Platform::Writable : 0) | (executable ? Platform::Executable : 0);
-
-  return platform->writeObject(out, Slice<SymbolInfo>(symbols, 2), Slice<const uint8_t>(data, size), accessFlags, alignment);
+  unsigned accessFlags = (writable ? Platform::Writable : 0)
+                         | (executable ? Platform::Executable : 0);
 
+  return platform->writeObject(out,
+                               Slice<SymbolInfo>(symbols, 2),
+                               Slice<const uint8_t>(data, size),
+                               accessFlags,
+                               alignment);
 }
 
-void
-usageAndExit(const char* name)
+void usageAndExit(const char* name)
 {
   fprintf(stderr,
           "usage: %s <input file> <output file> <start name> <end name> "
@@ -75,10 +86,9 @@ usageAndExit(const char* name)
   exit(-1);
 }
 
-} // namespace
+}  // namespace
 
-int
-main(int argc, const char** argv)
+int main(int argc, const char** argv)
 {
   if (argc < 7 or argc > 10) {
     usageAndExit(argv[0]);
@@ -111,26 +121,16 @@ main(int argc, const char** argv)
     if (r != -1) {
 #ifdef WIN32
       HANDLE fm;
-      HANDLE h = (HANDLE) _get_osfhandle (fd);
+      HANDLE h = (HANDLE)_get_osfhandle(fd);
 
-      fm = CreateFileMapping(
-               h,
-               NULL,
-               PAGE_READONLY,
-               0,
-               0,
-               NULL);
-      data = static_cast<uint8_t*>(MapViewOfFile(
-                fm,
-                FILE_MAP_READ,
-                0,
-                0,
-                s.st_size));
+      fm = CreateFileMapping(h, NULL, PAGE_READONLY, 0, 0, NULL);
+      data = static_cast<uint8_t*>(
+          MapViewOfFile(fm, FILE_MAP_READ, 0, 0, s.st_size));
 
       CloseHandle(fm);
 #else
-      data = static_cast<uint8_t*>
-        (mmap(0, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0));
+      data = static_cast<uint8_t*>(
+          mmap(0, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0));
 #endif
       size = s.st_size;
     }
@@ -142,9 +142,16 @@ main(int argc, const char** argv)
   if (data) {
     FileOutputStream out(argv[2]);
     if (out.isValid()) {
-      success = writeObject
-        (data, size, &out, argv[3], argv[4], argv[5], argv[6], alignment,
-         writable, executable);
+      success = writeObject(data,
+                            size,
+                            &out,
+                            argv[3],
+                            argv[4],
+                            argv[5],
+                            argv[6],
+                            alignment,
+                            writable,
+                            executable);
     } else {
       fprintf(stderr, "unable to open %s\n", argv[2]);
     }
diff --git a/src/tools/bootimage-generator/main.cpp b/src/tools/bootimage-generator/main.cpp
index d31940dc8b..70ce2e5459 100644
--- a/src/tools/bootimage-generator/main.cpp
+++ b/src/tools/bootimage-generator/main.cpp
@@ -26,7 +26,10 @@
 
 // since we aren't linking against libstdc++, we must implement this
 // ourselves:
-extern "C" void __cxa_pure_virtual(void) { abort(); }
+extern "C" void __cxa_pure_virtual(void)
+{
+  abort();
+}
 
 using namespace vm;
 using namespace avian::tools;
@@ -38,8 +41,8 @@ namespace {
 const unsigned HeapCapacity = 512 * 1024 * 1024;
 
 const unsigned TargetFixieSizeInBytes = 8 + (TargetBytesPerWord * 2);
-const unsigned TargetFixieSizeInWords = ceilingDivide
-  (TargetFixieSizeInBytes, TargetBytesPerWord);
+const unsigned TargetFixieSizeInWords
+    = ceilingDivide(TargetFixieSizeInBytes, TargetBytesPerWord);
 const unsigned TargetFixieAge = 0;
 const unsigned TargetFixieFlags = 2;
 const unsigned TargetFixieSize = 4;
@@ -78,9 +81,12 @@ class Field {
   unsigned targetSize;
 };
 
-void
-init(Field* f, Type type, unsigned buildOffset, unsigned buildSize,
-     unsigned targetOffset, unsigned targetSize)
+void init(Field* f,
+          Type type,
+          unsigned buildOffset,
+          unsigned buildSize,
+          unsigned targetOffset,
+          unsigned targetSize)
 {
   f->type = type;
   f->buildOffset = buildOffset;
@@ -91,41 +97,42 @@ init(Field* f, Type type, unsigned buildOffset, unsigned buildSize,
 
 class TypeMap {
  public:
-  enum Kind {
-    NormalKind,
-    SingletonKind,
-    PoolKind
-  };
+  enum Kind { NormalKind, SingletonKind, PoolKind };
 
-  TypeMap(unsigned buildFixedSizeInWords, unsigned targetFixedSizeInWords,
-          unsigned fixedFieldCount, Kind kind = NormalKind,
+  TypeMap(unsigned buildFixedSizeInWords,
+          unsigned targetFixedSizeInWords,
+          unsigned fixedFieldCount,
+          Kind kind = NormalKind,
           unsigned buildArrayElementSizeInBytes = 0,
           unsigned targetArrayElementSizeInBytes = 0,
-          Type arrayElementType = Type_none):
-    buildFixedSizeInWords(buildFixedSizeInWords),
-    targetFixedSizeInWords(targetFixedSizeInWords),
-    fixedFieldCount(fixedFieldCount),
-    buildArrayElementSizeInBytes(buildArrayElementSizeInBytes),
-    targetArrayElementSizeInBytes(targetArrayElementSizeInBytes),
-    arrayElementType(arrayElementType),
-    kind(kind)
-  { }
+          Type arrayElementType = Type_none)
+      : buildFixedSizeInWords(buildFixedSizeInWords),
+        targetFixedSizeInWords(targetFixedSizeInWords),
+        fixedFieldCount(fixedFieldCount),
+        buildArrayElementSizeInBytes(buildArrayElementSizeInBytes),
+        targetArrayElementSizeInBytes(targetArrayElementSizeInBytes),
+        arrayElementType(arrayElementType),
+        kind(kind)
+  {
+  }
 
-  uintptr_t* targetFixedOffsets() {
+  uintptr_t* targetFixedOffsets()
+  {
     return reinterpret_cast<uintptr_t*>(this + 1);
   }
 
-  Field* fixedFields() {
-    return reinterpret_cast<Field*>
-      (targetFixedOffsets() + (buildFixedSizeInWords * BytesPerWord));
+  Field* fixedFields()
+  {
+    return reinterpret_cast<Field*>(targetFixedOffsets()
+                                    + (buildFixedSizeInWords * BytesPerWord));
   }
 
   static unsigned sizeInBytes(unsigned buildFixedSizeInWords,
                               unsigned fixedFieldCount)
   {
     return sizeof(TypeMap)
-      + (buildFixedSizeInWords * BytesPerWord * BytesPerWord)
-      + (sizeof(Field) * fixedFieldCount);
+           + (buildFixedSizeInWords * BytesPerWord * BytesPerWord)
+           + (sizeof(Field) * fixedFieldCount);
   }
 
   unsigned buildFixedSizeInWords;
@@ -167,12 +174,11 @@ class TypeMap {
 //    of primitive classes before generating the heap image so that we
 //    need not populate them lazily at runtime.
 
-bool
-endsWith(const char* suffix, const char* s, unsigned length)
+bool endsWith(const char* suffix, const char* s, unsigned length)
 {
   unsigned suffixLength = strlen(suffix);
   return length >= suffixLength
-    and memcmp(suffix, s + (length - suffixLength), suffixLength) == 0;
+         and memcmp(suffix, s + (length - suffixLength), suffixLength) == 0;
 }
 
 GcVector* getNonStaticFields(Thread* t,
@@ -206,7 +212,7 @@ GcVector* getNonStaticFields(Thread* t,
         GcField* field = cast<GcField>(t, ftable->body()[i]);
 
         if ((field->flags() & ACC_STATIC) == 0) {
-          ++ (*count);
+          ++(*count);
           fields = vectorAppend(t, fields, reinterpret_cast<object>(field));
         }
       }
@@ -252,7 +258,7 @@ GcVector* allFields(Thread* t,
       GcField* field = cast<GcField>(t, ftable->body()[i]);
 
       if (includeMembers or (field->flags() & ACC_STATIC)) {
-        ++ (*count);
+        ++(*count);
         fields = vectorAppend(t, fields, reinterpret_cast<object>(field));
       }
     }
@@ -325,7 +331,7 @@ GcTriple* makeCodeImage(Thread* t,
 
   DelayedPromise* addresses = 0;
 
-  class MyOffsetResolver: public OffsetResolver {
+  class MyOffsetResolver : public OffsetResolver {
    public:
     MyOffsetResolver(GcHashMap** typeMaps) : typeMaps(typeMaps)
     {
@@ -347,8 +353,7 @@ GcTriple* makeCodeImage(Thread* t,
     const char* name = it.next(&nameSize);
 
     if (endsWith(".class", name, nameSize)
-        and (className == 0 or strncmp(name, className, nameSize - 6) == 0))
-    {
+        and (className == 0 or strncmp(name, className, nameSize - 6) == 0)) {
       // fprintf(stderr, "pass 1 %.*s\n", nameSize - 6, name);
       GcClass* c
           = resolveSystemClass(t,
@@ -359,14 +364,18 @@ GcTriple* makeCodeImage(Thread* t,
       PROTECT(t, c);
 
       System::Region* region = finder->find(name);
-      
-      { THREAD_RESOURCE(t, System::Region*, region, region->dispose());
 
-        class Client: public Stream::Client {
+      {
+        THREAD_RESOURCE(t, System::Region*, region, region->dispose());
+
+        class Client : public Stream::Client {
          public:
-          Client(Thread* t): t(t) { }
+          Client(Thread* t) : t(t)
+          {
+          }
 
-          virtual void NO_RETURN handleError() {
+          virtual void NO_RETURN handleError()
+          {
             abort(t);
           }
 
@@ -378,8 +387,8 @@ GcTriple* makeCodeImage(Thread* t,
 
         uint32_t magic = s.read4();
         expect(t, magic == 0xCAFEBABE);
-        s.read2(); // minor version
-        s.read2(); // major version
+        s.read2();  // minor version
+        s.read2();  // major version
 
         unsigned count = s.read2() - 1;
         if (count) {
@@ -426,7 +435,8 @@ GcTriple* makeCodeImage(Thread* t,
               s.skip(s.read2());
               break;
 
-            default: abort(t);
+            default:
+              abort(t);
             }
           }
 
@@ -439,11 +449,14 @@ GcTriple* makeCodeImage(Thread* t,
           for (unsigned i = 0; i < count + 2; ++i) {
             expect(t, i < map->buildFixedSizeInWords);
 
-            map->targetFixedOffsets()[i * BytesPerWord]
-              = i * TargetBytesPerWord;
+            map->targetFixedOffsets()[i * BytesPerWord] = i
+                                                          * TargetBytesPerWord;
 
-            init(new (map->fixedFields() + i) Field, RUNTIME_ARRAY_BODY(types)[i],
-                 i * BytesPerWord, BytesPerWord, i * TargetBytesPerWord,
+            init(new (map->fixedFields() + i) Field,
+                 RUNTIME_ARRAY_BODY(types)[i],
+                 i* BytesPerWord,
+                 BytesPerWord,
+                 i* TargetBytesPerWord,
                  TargetBytesPerWord);
           }
 
@@ -488,11 +501,15 @@ GcTriple* makeCodeImage(Thread* t,
 
             targetMemberOffset = f->targetOffset + f->targetSize;
 
-            ++ memberIndex;
+            ++memberIndex;
           }
         } else {
-          init(new (RUNTIME_ARRAY_BODY(memberFields)) Field, Type_object, 0,
-               BytesPerWord, 0, TargetBytesPerWord);
+          init(new (RUNTIME_ARRAY_BODY(memberFields)) Field,
+               Type_object,
+               0,
+               BytesPerWord,
+               0,
+               TargetBytesPerWord);
 
           memberIndex = 1;
           buildMemberOffset = BytesPerWord;
@@ -502,16 +519,26 @@ GcTriple* makeCodeImage(Thread* t,
         const unsigned StaticHeader = 3;
 
         THREAD_RUNTIME_ARRAY(t, Field, staticFields, count + StaticHeader);
-        
-        init(new (RUNTIME_ARRAY_BODY(staticFields)) Field, Type_object, 0,
-             BytesPerWord, 0, TargetBytesPerWord);
 
-        init(new (RUNTIME_ARRAY_BODY(staticFields) + 1) Field, Type_intptr_t,
-             BytesPerWord, BytesPerWord, TargetBytesPerWord,
+        init(new (RUNTIME_ARRAY_BODY(staticFields)) Field,
+             Type_object,
+             0,
+             BytesPerWord,
+             0,
              TargetBytesPerWord);
 
-        init(new (RUNTIME_ARRAY_BODY(staticFields) + 2) Field, Type_object,
-             BytesPerWord * 2, BytesPerWord, TargetBytesPerWord * 2,
+        init(new (RUNTIME_ARRAY_BODY(staticFields) + 1) Field,
+             Type_intptr_t,
+             BytesPerWord,
+             BytesPerWord,
+             TargetBytesPerWord,
+             TargetBytesPerWord);
+
+        init(new (RUNTIME_ARRAY_BODY(staticFields) + 2) Field,
+             Type_object,
+             BytesPerWord * 2,
+             BytesPerWord,
+             TargetBytesPerWord * 2,
              TargetBytesPerWord);
 
         unsigned staticIndex = StaticHeader;
@@ -551,7 +578,8 @@ GcTriple* makeCodeImage(Thread* t,
               type = Type_int64_t;
               break;
 
-            default: abort(t);
+            default:
+              abort(t);
             }
 
             if (field->flags() & ACC_STATIC) {
@@ -560,24 +588,30 @@ GcTriple* makeCodeImage(Thread* t,
               buildStaticOffset = field->offset();
 
               init(new (RUNTIME_ARRAY_BODY(staticFields) + staticIndex) Field,
-                   type, buildStaticOffset, buildSize, targetStaticOffset,
+                   type,
+                   buildStaticOffset,
+                   buildSize,
+                   targetStaticOffset,
                    targetSize);
 
               targetStaticOffset += targetSize;
 
-              ++ staticIndex;
+              ++staticIndex;
             } else {
               targetMemberOffset = pad(targetMemberOffset, targetSize);
 
               buildMemberOffset = field->offset();
 
               init(new (RUNTIME_ARRAY_BODY(memberFields) + memberIndex) Field,
-                   type, buildMemberOffset, buildSize, targetMemberOffset,
+                   type,
+                   buildMemberOffset,
+                   buildSize,
+                   targetMemberOffset,
                    targetSize);
 
               targetMemberOffset += targetSize;
 
-              ++ memberIndex;
+              ++memberIndex;
             }
           } else {
             targetMemberOffset = pad(targetMemberOffset, TargetBytesPerWord);
@@ -602,8 +636,8 @@ GcTriple* makeCodeImage(Thread* t,
           for (unsigned i = 0; i < memberIndex; ++i) {
             Field* f = RUNTIME_ARRAY_BODY(memberFields) + i;
 
-            expect(t, f->buildOffset
-                   < map->buildFixedSizeInWords * BytesPerWord);
+            expect(t,
+                   f->buildOffset < map->buildFixedSizeInWords * BytesPerWord);
 
             map->targetFixedOffsets()[f->buildOffset] = f->targetOffset;
 
@@ -632,8 +666,8 @@ GcTriple* makeCodeImage(Thread* t,
           for (unsigned i = 0; i < staticIndex; ++i) {
             Field* f = RUNTIME_ARRAY_BODY(staticFields) + i;
 
-            expect(t, f->buildOffset
-                   < map->buildFixedSizeInWords * BytesPerWord);
+            expect(t,
+                   f->buildOffset < map->buildFixedSizeInWords * BytesPerWord);
 
             map->targetFixedOffsets()[f->buildOffset] = f->targetOffset;
 
@@ -655,8 +689,7 @@ GcTriple* makeCodeImage(Thread* t,
     const char* name = it.next(&nameSize);
 
     if (endsWith(".class", name, nameSize)
-        and (className == 0 or strncmp(name, className, nameSize - 6) == 0))
-    {
+        and (className == 0 or strncmp(name, className, nameSize - 6) == 0)) {
       // fprintf(stderr, "pass 2 %.*s\n", nameSize - 6, name);
       GcClass* c = 0;
       PROTECT(t, c);
@@ -745,8 +778,7 @@ GcTriple* makeCodeImage(Thread* t,
     uint8_t* value = reinterpret_cast<uint8_t*>(addresses->basis->value());
     expect(t, value >= code);
 
-    addresses->listener->resolve
-      (static_cast<target_intptr_t>(value - code), 0);
+    addresses->listener->resolve(static_cast<target_intptr_t>(value - code), 0);
   }
 
   for (; methods; methods = cast<GcPair>(t, methods->second())) {
@@ -786,12 +818,11 @@ unsigned targetOffset(Thread* t, GcHashMap* typeMaps, object p, unsigned offset)
   TypeMap* map = typeMap(t, typeMaps, p);
 
   if (map->targetArrayElementSizeInBytes
-      and offset >= map->buildFixedSizeInWords * BytesPerWord)
-  {
+      and offset >= map->buildFixedSizeInWords * BytesPerWord) {
     return (map->targetFixedSizeInWords * TargetBytesPerWord)
-      + (((offset - (map->buildFixedSizeInWords * BytesPerWord))
-          / map->buildArrayElementSizeInBytes)
-         * map->targetArrayElementSizeInBytes);
+           + (((offset - (map->buildFixedSizeInWords * BytesPerWord))
+               / map->buildArrayElementSizeInBytes)
+              * map->targetArrayElementSizeInBytes);
   } else {
     return map->targetFixedOffsets()[offset];
   }
@@ -803,39 +834,42 @@ unsigned targetSize(Thread* t, GcHashMap* typeMaps, object p)
 
   if (map->targetArrayElementSizeInBytes) {
     return map->targetFixedSizeInWords
-      + ceilingDivide(map->targetArrayElementSizeInBytes
-                * fieldAtOffset<uintptr_t>
-                (p, (map->buildFixedSizeInWords - 1) * BytesPerWord),
-                TargetBytesPerWord);
+           + ceilingDivide(
+                 map->targetArrayElementSizeInBytes
+                 * fieldAtOffset<uintptr_t>(
+                       p, (map->buildFixedSizeInWords - 1) * BytesPerWord),
+                 TargetBytesPerWord);
   } else {
     switch (map->kind) {
     case TypeMap::NormalKind:
       return map->targetFixedSizeInWords;
 
     case TypeMap::SingletonKind:
-      return map->targetFixedSizeInWords + singletonMaskSize
-        (map->targetFixedSizeInWords - 2, TargetBitsPerWord);
+      return map->targetFixedSizeInWords
+             + singletonMaskSize(map->targetFixedSizeInWords - 2,
+                                 TargetBitsPerWord);
 
     case TypeMap::PoolKind: {
-      unsigned maskSize = poolMaskSize
-        (map->targetFixedSizeInWords - 2, TargetBitsPerWord);
+      unsigned maskSize
+          = poolMaskSize(map->targetFixedSizeInWords - 2, TargetBitsPerWord);
 
-      return map->targetFixedSizeInWords + maskSize + singletonMaskSize
-        (map->targetFixedSizeInWords - 2 + maskSize, TargetBitsPerWord);
+      return map->targetFixedSizeInWords + maskSize
+             + singletonMaskSize(map->targetFixedSizeInWords - 2 + maskSize,
+                                 TargetBitsPerWord);
     }
 
-    default: abort(t);
+    default:
+      abort(t);
     }
   }
 }
 
-unsigned
-objectMaskCount(TypeMap* map)
+unsigned objectMaskCount(TypeMap* map)
 {
   unsigned count = map->targetFixedSizeInWords;
 
   if (map->targetArrayElementSizeInBytes) {
-    ++ count;
+    ++count;
   }
 
   return count;
@@ -850,17 +884,16 @@ unsigned targetSize(Thread* t,
   if (referer and objectClass(t, referer) == type(t, GcClass::Type)
       and (refererOffset * BytesPerWord) == ClassObjectMask) {
     return (TargetBytesPerWord * 2)
-      + pad
-      (ceilingDivide
-       (objectMaskCount
-        (classTypeMap(t, typeMaps, referer)), 32) * 4, TargetBytesPerWord);
+           + pad(ceilingDivide(
+                     objectMaskCount(classTypeMap(t, typeMaps, referer)), 32)
+                 * 4,
+                 TargetBytesPerWord);
   } else {
     return targetSize(t, typeMaps, p);
   }
 }
 
-void
-copy(Thread* t, uint8_t* src, uint8_t* dst, Type type)
+void copy(Thread* t, uint8_t* src, uint8_t* dst, Type type)
 {
   switch (type) {
   case Type_int8_t:
@@ -868,21 +901,24 @@ copy(Thread* t, uint8_t* src, uint8_t* dst, Type type)
     break;
 
   case Type_int16_t: {
-    int16_t s; memcpy(&s, src, 2);
+    int16_t s;
+    memcpy(&s, src, 2);
     int16_t d = targetV2(s);
     memcpy(dst, &d, 2);
   } break;
 
   case Type_int32_t:
   case Type_float: {
-    int32_t s; memcpy(&s, src, 4);
+    int32_t s;
+    memcpy(&s, src, 4);
     int32_t d = targetV4(s);
     memcpy(dst, &d, 4);
   } break;
 
   case Type_int64_t:
   case Type_double: {
-    int64_t s; memcpy(&s, src, 8);
+    int64_t s;
+    memcpy(&s, src, 8);
     int64_t d = targetV8(s);
     memcpy(dst, &d, 8);
   } break;
@@ -892,7 +928,8 @@ copy(Thread* t, uint8_t* src, uint8_t* dst, Type type)
     break;
 
   case Type_intptr_t: {
-    intptr_t s; memcpy(&s, src, BytesPerWord);
+    intptr_t s;
+    memcpy(&s, src, BytesPerWord);
     target_intptr_t d = targetVW(s);
     memcpy(dst, &d, TargetBytesPerWord);
   } break;
@@ -901,12 +938,12 @@ copy(Thread* t, uint8_t* src, uint8_t* dst, Type type)
     memset(dst, 0, TargetBytesPerWord);
   } break;
 
-  default: abort(t);
+  default:
+    abort(t);
   }
 }
 
-bool
-nonObjectsEqual(uint8_t* src, uint8_t* dst, Type type)
+bool nonObjectsEqual(uint8_t* src, uint8_t* dst, Type type)
 {
   switch (type) {
   case Type_int8_t:
@@ -934,18 +971,17 @@ nonObjectsEqual(uint8_t* src, uint8_t* dst, Type type)
   case Type_object_nogc:
     return true;
 
-  default: abort();
-  }  
+  default:
+    abort();
+  }
 }
 
-bool
-nonObjectsEqual(TypeMap* map, uint8_t* src, uint8_t* dst)
+bool nonObjectsEqual(TypeMap* map, uint8_t* src, uint8_t* dst)
 {
   for (unsigned i = 0; i < map->fixedFieldCount; ++i) {
     Field* field = map->fixedFields() + i;
-    if (not nonObjectsEqual
-        (src + field->buildOffset, dst + field->targetOffset, field->type))
-    {
+    if (not nonObjectsEqual(
+            src + field->buildOffset, dst + field->targetOffset, field->type)) {
       return false;
     }
   }
@@ -955,11 +991,11 @@ nonObjectsEqual(TypeMap* map, uint8_t* src, uint8_t* dst)
     unsigned count = fieldAtOffset<uintptr_t>(src, fixedSize - BytesPerWord);
 
     for (unsigned i = 0; i < count; ++i) {
-      if (not nonObjectsEqual
-          (src + fixedSize + (i * map->buildArrayElementSizeInBytes),
-           dst + (map->targetFixedSizeInWords * TargetBytesPerWord)
-           + (i * map->targetArrayElementSizeInBytes), map->arrayElementType))
-      {
+      if (not nonObjectsEqual(
+              src + fixedSize + (i * map->buildArrayElementSizeInBytes),
+              dst + (map->targetFixedSizeInWords * TargetBytesPerWord)
+              + (i * map->targetArrayElementSizeInBytes),
+              map->arrayElementType)) {
         return false;
       }
     }
@@ -971,12 +1007,13 @@ nonObjectsEqual(TypeMap* map, uint8_t* src, uint8_t* dst)
 void copy(Thread* t, GcHashMap* typeMaps, object p, uint8_t* dst)
 {
   TypeMap* map = typeMap(t, typeMaps, p);
-  
+
   uint8_t* src = reinterpret_cast<uint8_t*>(p);
 
   for (unsigned i = 0; i < map->fixedFieldCount; ++i) {
     Field* field = map->fixedFields() + i;
-    if (field->type > Type_array) abort(t);
+    if (field->type > Type_array)
+      abort(t);
     copy(t, src + field->buildOffset, dst + field->targetOffset, field->type);
   }
 
@@ -985,9 +1022,11 @@ void copy(Thread* t, GcHashMap* typeMaps, object p, uint8_t* dst)
     unsigned count = fieldAtOffset<uintptr_t>(p, fixedSize - BytesPerWord);
 
     for (unsigned i = 0; i < count; ++i) {
-      copy(t, src + fixedSize + (i * map->buildArrayElementSizeInBytes),
+      copy(t,
+           src + fixedSize + (i * map->buildArrayElementSizeInBytes),
            dst + (map->targetFixedSizeInWords * TargetBytesPerWord)
-           + (i * map->targetArrayElementSizeInBytes), map->arrayElementType);
+           + (i * map->targetArrayElementSizeInBytes),
+           map->arrayElementType);
     }
 
     if (objectClass(t, p) == type(t, GcClass::Type)) {
@@ -1003,8 +1042,8 @@ void copy(Thread* t, GcHashMap* typeMaps, object p, uint8_t* dst)
       if (array) {
         TypeMap* classMap = reinterpret_cast<TypeMap*>(array->body().begin());
 
-        fixedSize = targetV2
-          (classMap->targetFixedSizeInWords * TargetBytesPerWord);
+        fixedSize
+            = targetV2(classMap->targetFixedSizeInWords * TargetBytesPerWord);
 
         arrayElementSize = classMap->targetArrayElementSizeInBytes;
       } else if (c->fixedSize() == BytesPerWord * 2
@@ -1016,15 +1055,16 @@ void copy(Thread* t, GcHashMap* typeMaps, object p, uint8_t* dst)
         fixedSize = 0;
         arrayElementSize = 0;
       }
-  
+
       if (fixedSize) {
         memcpy(dst + TargetClassFixedSize, &fixedSize, 2);
 
         memcpy(dst + TargetClassArrayElementSize, &arrayElementSize, 1);
       }
-      
+
       // if (strcmp("vm::lineNumberTable",
-      //            reinterpret_cast<const char*>(&byteArrayBody(t, className(t, p), 0))) == 0) trap();
+      //            reinterpret_cast<const char*>(&byteArrayBody(t, className(t,
+      //            p), 0))) == 0) trap();
     }
   } else {
     switch (map->kind) {
@@ -1037,11 +1077,11 @@ void copy(Thread* t, GcHashMap* typeMaps, object p, uint8_t* dst)
       break;
 
     case TypeMap::SingletonKind: {
-      unsigned maskSize = singletonMaskSize
-        (map->targetFixedSizeInWords - 2, TargetBitsPerWord);
+      unsigned maskSize = singletonMaskSize(map->targetFixedSizeInWords - 2,
+                                            TargetBitsPerWord);
 
-      target_uintptr_t targetLength = targetVW
-        (map->targetFixedSizeInWords - 2 + maskSize);
+      target_uintptr_t targetLength
+          = targetVW(map->targetFixedSizeInWords - 2 + maskSize);
       memcpy(dst + TargetBytesPerWord, &targetLength, TargetBytesPerWord);
 
       uint8_t* mask = dst + (map->targetFixedSizeInWords * TargetBytesPerWord);
@@ -1052,38 +1092,38 @@ void copy(Thread* t, GcHashMap* typeMaps, object p, uint8_t* dst)
         if (field->type == Type_object) {
           unsigned offset = field->targetOffset / TargetBytesPerWord;
           reinterpret_cast<uint32_t*>(mask)[offset / 32]
-            |= targetV4(static_cast<uint32_t>(1) << (offset % 32));
+              |= targetV4(static_cast<uint32_t>(1) << (offset % 32));
         }
       }
 
       if (DebugNativeTarget) {
-        expect
-          (t, memcmp
-           (src + (map->targetFixedSizeInWords * TargetBytesPerWord), mask,
-            singletonMaskSize
-            (map->targetFixedSizeInWords - 2, TargetBitsPerWord)
-            * TargetBytesPerWord) == 0);
+        expect(t,
+               memcmp(src + (map->targetFixedSizeInWords * TargetBytesPerWord),
+                      mask,
+                      singletonMaskSize(map->targetFixedSizeInWords - 2,
+                                        TargetBitsPerWord) * TargetBytesPerWord)
+               == 0);
       }
     } break;
 
     case TypeMap::PoolKind: {
-      unsigned poolMaskSize = vm::poolMaskSize
-        (map->targetFixedSizeInWords - 2, TargetBitsPerWord);
+      unsigned poolMaskSize = vm::poolMaskSize(map->targetFixedSizeInWords - 2,
+                                               TargetBitsPerWord);
 
-      unsigned objectMaskSize = singletonMaskSize
-        (map->targetFixedSizeInWords - 2 + poolMaskSize, TargetBitsPerWord);
+      unsigned objectMaskSize = singletonMaskSize(
+          map->targetFixedSizeInWords - 2 + poolMaskSize, TargetBitsPerWord);
 
-      target_uintptr_t targetLength = targetVW
-        (map->targetFixedSizeInWords - 2 + poolMaskSize + objectMaskSize);
+      target_uintptr_t targetLength = targetVW(map->targetFixedSizeInWords - 2
+                                               + poolMaskSize + objectMaskSize);
       memcpy(dst + TargetBytesPerWord, &targetLength, TargetBytesPerWord);
 
       uint8_t* poolMask = dst
-        + (map->targetFixedSizeInWords * TargetBytesPerWord);
+                          + (map->targetFixedSizeInWords * TargetBytesPerWord);
 
       memset(poolMask, 0, poolMaskSize * TargetBytesPerWord);
 
-      uint8_t* objectMask = dst
-        + ((map->targetFixedSizeInWords + poolMaskSize) * TargetBytesPerWord);
+      uint8_t* objectMask = dst + ((map->targetFixedSizeInWords + poolMaskSize)
+                                   * TargetBytesPerWord);
 
       memset(objectMask, 0, objectMaskSize * TargetBytesPerWord);
 
@@ -1092,15 +1132,14 @@ void copy(Thread* t, GcHashMap* typeMaps, object p, uint8_t* dst)
         switch (field->type) {
         case Type_object:
           reinterpret_cast<uint32_t*>(objectMask)[i / 32]
-            |= targetV4(static_cast<uint32_t>(1) << (i % 32));
+              |= targetV4(static_cast<uint32_t>(1) << (i % 32));
           break;
 
         case Type_float:
         case Type_double:
-          reinterpret_cast<target_uintptr_t*>(poolMask)
-            [i / TargetBitsPerWord]
-            |= targetVW
-            (static_cast<target_uintptr_t>(1) << (i % TargetBitsPerWord));
+          reinterpret_cast<target_uintptr_t*>(poolMask)[i / TargetBitsPerWord]
+              |= targetVW(static_cast<target_uintptr_t>(1)
+                          << (i % TargetBitsPerWord));
           break;
 
         default:
@@ -1109,17 +1148,18 @@ void copy(Thread* t, GcHashMap* typeMaps, object p, uint8_t* dst)
       }
 
       if (DebugNativeTarget) {
-        expect
-          (t, memcmp
-           (src + (map->targetFixedSizeInWords * TargetBytesPerWord), poolMask,
-            (poolMaskSize + singletonMaskSize
-             (map->targetFixedSizeInWords - 2 + poolMaskSize,
-              TargetBitsPerWord))
-            * TargetBytesPerWord) == 0);
+        expect(t,
+               memcmp(src + (map->targetFixedSizeInWords * TargetBytesPerWord),
+                      poolMask,
+                      (poolMaskSize
+                       + singletonMaskSize(
+                             map->targetFixedSizeInWords - 2 + poolMaskSize,
+                             TargetBitsPerWord)) * TargetBytesPerWord) == 0);
       }
     } break;
 
-    default: abort(t);
+    default:
+      abort(t);
     }
   }
 }
@@ -1149,17 +1189,16 @@ void copy(Thread* t,
       Field* field = map->fixedFields() + i;
       if (field->type == Type_object) {
         unsigned offset = field->targetOffset / TargetBytesPerWord;
-        reinterpret_cast<uint32_t*>(dst + (TargetBytesPerWord * 2))
-          [offset / 32] |= targetV4(static_cast<uint32_t>(1) << (offset % 32));
+        reinterpret_cast<uint32_t*>(dst + (TargetBytesPerWord * 2))[offset / 32]
+            |= targetV4(static_cast<uint32_t>(1) << (offset % 32));
       }
     }
 
     if (map->targetArrayElementSizeInBytes
-        and map->arrayElementType == Type_object)
-    {
+        and map->arrayElementType == Type_object) {
       unsigned offset = map->targetFixedSizeInWords;
-      reinterpret_cast<uint32_t*>(dst + (TargetBytesPerWord * 2))
-        [offset / 32] |= targetV4(static_cast<uint32_t>(1) << (offset % 32));
+      reinterpret_cast<uint32_t*>(dst + (TargetBytesPerWord * 2))[offset / 32]
+          |= targetV4(static_cast<uint32_t>(1) << (offset % 32));
     }
   } else {
     copy(t, typeMaps, p, dst);
@@ -1167,8 +1206,9 @@ void copy(Thread* t,
 
   if (DebugNativeTarget) {
     expect(t, targetSize(t, typeMaps, p) == baseSize(t, p, objectClass(t, p)));
-    expect(t, nonObjectsEqual
-           (typeMap(t, typeMaps, p), reinterpret_cast<uint8_t*>(p), dst));
+    expect(t,
+           nonObjectsEqual(
+               typeMap(t, typeMaps, p), reinterpret_cast<uint8_t*>(p), dst));
   }
 }
 
@@ -1180,7 +1220,7 @@ HeapWalker* makeHeapImage(Thread* t,
                           GcTriple* constants,
                           GcHashMap* typeMaps)
 {
-  class Visitor: public HeapVisitor {
+  class Visitor : public HeapVisitor {
    public:
     Visitor(Thread* t,
             GcHashMap* typeMaps,
@@ -1196,39 +1236,45 @@ HeapWalker* makeHeapImage(Thread* t,
           map(map),
           position(0),
           capacity(capacity)
-    { }
+    {
+    }
 
-    void visit(unsigned number) {
+    void visit(unsigned number)
+    {
       if (currentObject) {
         if (DebugNativeTarget) {
-          expect
-            (t, targetOffset
-             (t, typeMaps, currentObject, currentOffset * BytesPerWord)
-             == currentOffset * BytesPerWord);
+          expect(t,
+                 targetOffset(
+                     t, typeMaps, currentObject, currentOffset * BytesPerWord)
+                 == currentOffset * BytesPerWord);
         }
 
-        unsigned offset = currentNumber - 1
-          + (targetOffset
-             (t, typeMaps, currentObject, currentOffset * BytesPerWord)
-             / TargetBytesPerWord);
+        unsigned offset
+            = currentNumber - 1
+              + (targetOffset(
+                     t, typeMaps, currentObject, currentOffset * BytesPerWord)
+                 / TargetBytesPerWord);
 
         unsigned mark = heap[offset] & (~TargetPointerMask);
         unsigned value = number | (mark << TargetBootShift);
 
-        if (value) targetMarkBit(map, offset);
+        if (value)
+          targetMarkBit(map, offset);
 
         heap[offset] = targetVW(value);
       }
     }
 
-    virtual void root() {
+    virtual void root()
+    {
       currentObject = 0;
     }
 
-    virtual unsigned visitNew(object p) {
+    virtual unsigned visitNew(object p)
+    {
       if (p) {
-        unsigned size = targetSize
-          (t, typeMaps, currentObject, currentOffset, p);
+        unsigned size
+            = targetSize(t, typeMaps, currentObject, currentOffset, p);
 
         unsigned number;
         if ((currentObject
@@ -1253,23 +1299,31 @@ HeapWalker* makeHeapImage(Thread* t,
           memset(heap + position, 0, TargetFixieSizeInBytes);
 
           uint16_t age = targetV2(FixieTenureThreshold + 1);
-          memcpy(reinterpret_cast<uint8_t*>(heap + position)
-                 + TargetFixieAge, &age, 2);
+          memcpy(reinterpret_cast<uint8_t*>(heap + position) + TargetFixieAge,
+                 &age,
+                 2);
 
           uint16_t flags = targetV2(1);
-          memcpy(reinterpret_cast<uint8_t*>(heap + position)
-                 + TargetFixieFlags, &flags, 2);
+          memcpy(reinterpret_cast<uint8_t*>(heap + position) + TargetFixieFlags,
+                 &flags,
+                 2);
 
           uint32_t targetSize = targetV4(size);
-          memcpy(reinterpret_cast<uint8_t*>(heap + position)
-                 + TargetFixieSize, &targetSize, 4);
+          memcpy(reinterpret_cast<uint8_t*>(heap + position) + TargetFixieSize,
+                 &targetSize,
+                 4);
 
-          copy(t, typeMaps, currentObject, currentOffset, p,
+          copy(t,
+               typeMaps,
+               currentObject,
+               currentOffset,
+               p,
                reinterpret_cast<uint8_t*>(dst));
 
           dst[0] |= FixedMark;
 
-          memset(heap + position + TargetFixieSizeInWords + size, 0,
+          memset(heap + position + TargetFixieSizeInWords + size,
+                 0,
                  maskSize * TargetBytesPerWord);
 
           number = (dst - heap) + 1;
@@ -1277,7 +1331,11 @@ HeapWalker* makeHeapImage(Thread* t,
         } else {
           expect(t, position + size < capacity);
 
-          copy(t, typeMaps, currentObject, currentOffset, p,
+          copy(t,
+               typeMaps,
+               currentObject,
+               currentOffset,
+               p,
                reinterpret_cast<uint8_t*>(heap + position));
 
           number = position + 1;
@@ -1292,17 +1350,20 @@ HeapWalker* makeHeapImage(Thread* t,
       }
     }
 
-    virtual void visitOld(object, unsigned number) {
+    virtual void visitOld(object, unsigned number)
+    {
       visit(number);
     }
 
-    virtual void push(object object, unsigned number, unsigned offset) {
+    virtual void push(object object, unsigned number, unsigned offset)
+    {
       currentObject = object;
       currentNumber = number;
       currentOffset = offset;
     }
 
-    virtual void pop() {
+    virtual void pop()
+    {
       currentObject = 0;
     }
 
@@ -1319,7 +1380,7 @@ HeapWalker* makeHeapImage(Thread* t,
 
   HeapWalker* w = makeHeapWalker(t, &visitor);
   visitRoots(t, image, w, constants);
-  
+
   image->heapSize = visitor.position * TargetBytesPerWord;
 
   return w;
@@ -1341,20 +1402,25 @@ void updateConstants(Thread* t, GcTriple* constants, HeapMap* heapTable)
   }
 }
 
-BootImage::Thunk
-targetThunk(BootImage::Thunk t)
+BootImage::Thunk targetThunk(BootImage::Thunk t)
 {
-  return BootImage::Thunk
-    (targetV4(t.start), targetV4(t.frameSavedOffset), targetV4(t.length));
+  return BootImage::Thunk(
+      targetV4(t.start), targetV4(t.frameSavedOffset), targetV4(t.length));
 }
 
-void
-writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutput,
-                BootImage* image, uint8_t* code, const char* className,
-                const char* methodName, const char* methodSpec,
-                const char* bootimageStart, const char* bootimageEnd,
-                const char* codeimageStart, const char* codeimageEnd,
-                bool useLZMA)
+void writeBootImage2(Thread* t,
+                     OutputStream* bootimageOutput,
+                     OutputStream* codeOutput,
+                     BootImage* image,
+                     uint8_t* code,
+                     const char* className,
+                     const char* methodName,
+                     const char* methodSpec,
+                     const char* bootimageStart,
+                     const char* bootimageEnd,
+                     const char* codeimageStart,
+                     const char* codeimageEnd,
+                     bool useLZMA)
 {
   GcThrowable* throwable
       = cast<GcThrowable>(t, make(t, type(t, GcOutOfMemoryError::Type)));
@@ -1365,8 +1431,8 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
 
   class MyCompilationHandler : public Processor::CompilationHandler {
    public:
-
-    String heapDup(const char* name) {
+    String heapDup(const char* name)
+    {
       String ret(name);
       char* n = (char*)heap->allocate(ret.length + 1);
       memcpy(n, ret.text, ret.length + 1);
@@ -1374,21 +1440,28 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
       return ret;
     }
 
-    virtual void compiled(const void* code, unsigned size UNUSED, unsigned frameSize UNUSED, const char* name) {
+    virtual void compiled(const void* code,
+                          unsigned size UNUSED,
+                          unsigned frameSize UNUSED,
+                          const char* name)
+    {
       uint64_t offset = reinterpret_cast<uint64_t>(code) - codeOffset;
       symbols.add(SymbolInfo(offset, heapDup(name)));
       // printf("%ld %ld %s.%s%s\n", offset, offset + size, class_, name, spec);
     }
 
-    virtual void dispose() {}
+    virtual void dispose()
+    {
+    }
 
     DynamicArray<SymbolInfo> symbols;
     uint64_t codeOffset;
     Heap* heap;
 
-    MyCompilationHandler(uint64_t codeOffset, Heap* heap):
-      codeOffset(codeOffset),
-      heap(heap) {}
+    MyCompilationHandler(uint64_t codeOffset, Heap* heap)
+        : codeOffset(codeOffset), heap(heap)
+    {
+    }
 
   } compilationHandler(reinterpret_cast<uint64_t>(code), t->m->heap);
 
@@ -1398,7 +1471,8 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
   GcHashMap* typeMaps;
   GcTriple* constants;
 
-  { classPoolMap = makeHashMap(t, 0, 0);
+  {
+    classPoolMap = makeHashMap(t, 0, 0);
     PROTECT(t, classPoolMap);
 
     roots(t)->setPoolMap(t, classPoolMap);
@@ -1413,16 +1487,20 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
       unsigned typeCount = 0;
       unsigned fieldCount = 1;
       while (source[typeCount] != Type_none) {
-        ++ typeCount;
+        ++typeCount;
         if (source[typeCount] != Type_pad) {
-          ++ fieldCount;
+          ++fieldCount;
         }
       }
 
       THREAD_RUNTIME_ARRAY(t, Field, fields, fieldCount);
 
-      init(new (RUNTIME_ARRAY_BODY(fields)) Field, Type_object, 0,
-           BytesPerWord, 0, TargetBytesPerWord);
+      init(new (RUNTIME_ARRAY_BODY(fields)) Field,
+           Type_object,
+           0,
+           BytesPerWord,
+           0,
+           TargetBytesPerWord);
 
       unsigned buildOffset = BytesPerWord;
       unsigned targetOffset = TargetBytesPerWord;
@@ -1490,7 +1568,8 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
           buildSize = targetSize = 0;
           break;
 
-        default: abort(t);
+        default:
+          abort(t);
         }
 
         if (source[j] == Type_array) {
@@ -1506,8 +1585,12 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
 
           targetOffset = pad(targetOffset, targetSize);
 
-          init(new (RUNTIME_ARRAY_BODY(fields) + (fieldOffset++)) Field, type,
-               buildOffset, buildSize, targetOffset, targetSize);
+          init(new (RUNTIME_ARRAY_BODY(fields) + (fieldOffset++)) Field,
+               type,
+               buildOffset,
+               buildSize,
+               targetOffset,
+               targetSize);
 
           buildOffset += buildSize;
           targetOffset += targetSize;
@@ -1521,7 +1604,7 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
       if (sawArray) {
         fixedFieldCount = fieldCount - 2;
         arrayElementType = type;
-        buildArrayElementSize = buildSize; 
+        buildArrayElementSize = buildSize;
         targetArrayElementSize = targetSize;
       } else {
         fixedFieldCount = fieldCount;
@@ -1547,8 +1630,7 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
       for (unsigned j = 0; j < fixedFieldCount; ++j) {
         Field* f = RUNTIME_ARRAY_BODY(fields) + j;
 
-        expect(t, f->buildOffset
-               < map->buildFixedSizeInWords * BytesPerWord);
+        expect(t, f->buildOffset < map->buildFixedSizeInWords * BytesPerWord);
 
         map->targetFixedOffsets()[f->buildOffset] = f->targetOffset;
 
@@ -1563,8 +1645,8 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
           objectHash);
     }
 
-    constants = makeCodeImage
-      (t, &zone, image, code, className, methodName, methodSpec, typeMaps);
+    constants = makeCodeImage(
+        t, &zone, image, code, className, methodName, methodSpec, typeMaps);
 
     PROTECT(t, constants);
 
@@ -1645,25 +1727,26 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
     }
   }
 
-  target_uintptr_t* heap = static_cast<target_uintptr_t*>
-    (t->m->heap->allocate(HeapCapacity));
+  target_uintptr_t* heap
+      = static_cast<target_uintptr_t*>(t->m->heap->allocate(HeapCapacity));
 
-  target_uintptr_t* heapMap = static_cast<target_uintptr_t*>
-    (t->m->heap->allocate(heapMapSize(HeapCapacity)));
+  target_uintptr_t* heapMap = static_cast<target_uintptr_t*>(
+      t->m->heap->allocate(heapMapSize(HeapCapacity)));
   memset(heapMap, 0, heapMapSize(HeapCapacity));
 
-  HeapWalker* heapWalker = makeHeapImage
-    (t, image, heap, heapMap, HeapCapacity, constants, typeMaps);
+  HeapWalker* heapWalker = makeHeapImage(
+      t, image, heap, heapMap, HeapCapacity, constants, typeMaps);
 
   updateConstants(t, constants, heapWalker->map());
 
   image->bootClassCount
       = cast<GcHashMap>(t, roots(t)->bootLoader()->map())->size();
 
-  unsigned* bootClassTable = static_cast<unsigned*>
-    (t->m->heap->allocate(image->bootClassCount * sizeof(unsigned)));
+  unsigned* bootClassTable = static_cast<unsigned*>(
+      t->m->heap->allocate(image->bootClassCount * sizeof(unsigned)));
 
-  { unsigned i = 0;
+  {
+    unsigned i = 0;
     for (HashMapIterator it(t,
                             cast<GcHashMap>(t, roots(t)->bootLoader()->map()));
          it.hasMore();) {
@@ -1675,10 +1758,11 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
   image->appClassCount
       = cast<GcHashMap>(t, roots(t)->appLoader()->map())->size();
 
-  unsigned* appClassTable = static_cast<unsigned*>
-    (t->m->heap->allocate(image->appClassCount * sizeof(unsigned)));
+  unsigned* appClassTable = static_cast<unsigned*>(
+      t->m->heap->allocate(image->appClassCount * sizeof(unsigned)));
 
-  { unsigned i = 0;
+  {
+    unsigned i = 0;
     for (
         HashMapIterator it(t, cast<GcHashMap>(t, roots(t)->appLoader()->map()));
         it.hasMore();) {
@@ -1688,10 +1772,11 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
   }
 
   image->stringCount = roots(t)->stringMap()->size();
-  unsigned* stringTable = static_cast<unsigned*>
-    (t->m->heap->allocate(image->stringCount * sizeof(unsigned)));
+  unsigned* stringTable = static_cast<unsigned*>(
+      t->m->heap->allocate(image->stringCount * sizeof(unsigned)));
 
-  { unsigned i = 0;
+  {
+    unsigned i = 0;
     for (HashMapIterator it(t, roots(t)->stringMap()); it.hasMore();) {
       stringTable[i++]
           = targetVW(heapWalker->map()->find(reinterpret_cast<object>(
@@ -1706,18 +1791,23 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
   image->magic = BootImage::Magic;
   image->initialized = 0;
 
-  fprintf(stderr, "class count %d string count %d call count %d\n"
+  fprintf(stderr,
+          "class count %d string count %d call count %d\n"
           "heap size %d code size %d\n",
-          image->bootClassCount, image->stringCount, image->callCount,
-          image->heapSize, image->codeSize);
+          image->bootClassCount,
+          image->stringCount,
+          image->callCount,
+          image->heapSize,
+          image->codeSize);
 
   Buffer bootimageData;
 
   if (true) {
-    { BootImage targetImage;
+    {
+      BootImage targetImage;
 
 #ifdef FIELD
-#  undef FIELD
+#undef FIELD
 #endif
 
 #define FIELD(name) targetImage.name = targetV4(image->name);
@@ -1725,54 +1815,63 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
 #undef FIELD
 
 #define THUNK_FIELD(name) \
-      targetImage.thunks.name = targetThunk(image->thunks.name);
+  targetImage.thunks.name = targetThunk(image->thunks.name);
 #include "bootimage-fields.cpp"
 #undef THUNK_FIELD
 
       bootimageData.write(&targetImage, sizeof(BootImage));
     }
 
-    bootimageData.write(bootClassTable, image->bootClassCount * sizeof(unsigned));
+    bootimageData.write(bootClassTable,
+                        image->bootClassCount * sizeof(unsigned));
     bootimageData.write(appClassTable, image->appClassCount * sizeof(unsigned));
     bootimageData.write(stringTable, image->stringCount * sizeof(unsigned));
     bootimageData.write(callTable, image->callCount * sizeof(unsigned) * 2);
 
     unsigned offset = sizeof(BootImage)
-      + (image->bootClassCount * sizeof(unsigned))
-      + (image->appClassCount * sizeof(unsigned))
-      + (image->stringCount * sizeof(unsigned))
-      + (image->callCount * sizeof(unsigned) * 2);
+                      + (image->bootClassCount * sizeof(unsigned))
+                      + (image->appClassCount * sizeof(unsigned))
+                      + (image->stringCount * sizeof(unsigned))
+                      + (image->callCount * sizeof(unsigned) * 2);
 
     while (offset % TargetBytesPerWord) {
       uint8_t c = 0;
       bootimageData.write(&c, 1);
-      ++ offset;
+      ++offset;
     }
 
-    bootimageData.write(heapMap, pad(heapMapSize(image->heapSize), TargetBytesPerWord));
+    bootimageData.write(heapMap,
+                        pad(heapMapSize(image->heapSize), TargetBytesPerWord));
 
     bootimageData.write(heap, pad(image->heapSize, TargetBytesPerWord));
 
     // fwrite(code, pad(image->codeSize, TargetBytesPerWord), 1, codeOutput);
-    
-    Platform* platform = Platform::getPlatform(PlatformInfo((PlatformInfo::Format)AVIAN_TARGET_FORMAT, (PlatformInfo::Architecture)AVIAN_TARGET_ARCH));
 
-    if(!platform) {
-      fprintf(stderr, "unsupported platform: target-format = %d / target-arch = %d\n", AVIAN_TARGET_FORMAT, AVIAN_TARGET_ARCH);
+    Platform* platform = Platform::getPlatform(
+        PlatformInfo((PlatformInfo::Format)AVIAN_TARGET_FORMAT,
+                     (PlatformInfo::Architecture)AVIAN_TARGET_ARCH));
+
+    if (!platform) {
+      fprintf(stderr,
+              "unsupported platform: target-format = %d / target-arch = %d\n",
+              AVIAN_TARGET_FORMAT,
+              AVIAN_TARGET_ARCH);
       abort();
     }
 
-    SymbolInfo bootimageSymbols[] = {
-      SymbolInfo(0, bootimageStart),
-      SymbolInfo(bootimageData.length, bootimageEnd)
-    };
+    SymbolInfo bootimageSymbols[]
+        = {SymbolInfo(0, bootimageStart),
+           SymbolInfo(bootimageData.length, bootimageEnd)};
 
     uint8_t* bootimage;
     unsigned bootimageLength;
     if (useLZMA) {
 #ifdef AVIAN_USE_LZMA
-      bootimage = encodeLZMA(t->m->system, t->m->heap, bootimageData.data,
-                             bootimageData.length, &bootimageLength);
+      bootimage = encodeLZMA(t->m->system,
+                             t->m->heap,
+                             bootimageData.data,
+                             bootimageData.length,
+                             &bootimageLength);
 
       fprintf(stderr, "compressed heap size %d\n", bootimageLength);
 #else
@@ -1783,7 +1882,11 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
       bootimageLength = bootimageData.length;
     }
 
-    platform->writeObject(bootimageOutput, Slice<SymbolInfo>(bootimageSymbols, 2), Slice<const uint8_t>(bootimage, bootimageLength), Platform::Writable, TargetBytesPerWord);
+    platform->writeObject(bootimageOutput,
+                          Slice<SymbolInfo>(bootimageSymbols, 2),
+                          Slice<const uint8_t>(bootimage, bootimageLength),
+                          Platform::Writable,
+                          TargetBytesPerWord);
 
     if (useLZMA) {
       t->m->heap->free(bootimage, bootimageLength);
@@ -1792,16 +1895,22 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
     compilationHandler.symbols.add(SymbolInfo(0, codeimageStart));
     compilationHandler.symbols.add(SymbolInfo(image->codeSize, codeimageEnd));
 
-    platform->writeObject(codeOutput, Slice<SymbolInfo>(compilationHandler.symbols), Slice<const uint8_t>(code, image->codeSize), Platform::Executable, TargetBytesPerWord);
+    platform->writeObject(codeOutput,
+                          Slice<SymbolInfo>(compilationHandler.symbols),
+                          Slice<const uint8_t>(code, image->codeSize),
+                          Platform::Executable,
+                          TargetBytesPerWord);
 
-    for(SymbolInfo* sym = compilationHandler.symbols.begin(); sym != compilationHandler.symbols.end() - 2; sym++) {
-      t->m->heap->free(const_cast<void*>((const void*)sym->name.text), sym->name.length + 1);
+    for (SymbolInfo* sym = compilationHandler.symbols.begin();
+         sym != compilationHandler.symbols.end() - 2;
+         sym++) {
+      t->m->heap->free(const_cast<void*>((const void*)sym->name.text),
+                       sym->name.length + 1);
     }
   }
 }
 
-uint64_t
-writeBootImage(Thread* t, uintptr_t* arguments)
+uint64_t writeBootImage(Thread* t, uintptr_t* arguments)
 {
   OutputStream* bootimageOutput = reinterpret_cast<OutputStream*>(arguments[0]);
   OutputStream* codeOutput = reinterpret_cast<OutputStream*>(arguments[1]);
@@ -1817,16 +1926,24 @@ writeBootImage(Thread* t, uintptr_t* arguments)
   const char* codeimageEnd = reinterpret_cast<const char*>(arguments[10]);
   bool useLZMA = arguments[11];
 
-  writeBootImage2
-    (t, bootimageOutput, codeOutput, image, code, className, methodName,
-     methodSpec, bootimageStart, bootimageEnd, codeimageStart, codeimageEnd,
-     useLZMA);
+  writeBootImage2(t,
+                  bootimageOutput,
+                  codeOutput,
+                  image,
+                  code,
+                  className,
+                  methodName,
+                  methodSpec,
+                  bootimageStart,
+                  bootimageEnd,
+                  codeimageStart,
+                  codeimageEnd,
+                  useLZMA);
 
   return 1;
 }
 
-char*
-myStrndup(const char* src, unsigned length)
+char* myStrndup(const char* src, unsigned length)
 {
   char* s = static_cast<char*>(malloc(length + 1));
   memcpy(s, src, length);
@@ -1835,8 +1952,7 @@ myStrndup(const char* src, unsigned length)
 }
 
 class Arguments {
-public:
-
+ public:
   const char* classpath;
 
   const char* bootimage;
@@ -1854,10 +1970,11 @@ public:
 
   bool useLZMA;
 
-  bool maybeSplit(const char* src, char*& destA, char*& destB) {
-    if(src) {
+  bool maybeSplit(const char* src, char*& destA, char*& destB)
+  {
+    if (src) {
       const char* split = strchr(src, ':');
-      if(!split) {
+      if (!split) {
         return false;
       }
 
@@ -1867,25 +1984,32 @@ public:
     return true;
   }
 
-  Arguments(int ac, const char** av):
-    entryClass(0),
-    entryMethod(0),
-    entrySpec(0),
-    bootimageStart(0),
-    bootimageEnd(0),
-    codeimageStart(0),
-    codeimageEnd(0)
+  Arguments(int ac, const char** av)
+      : entryClass(0),
+        entryMethod(0),
+        entrySpec(0),
+        bootimageStart(0),
+        bootimageEnd(0),
+        codeimageStart(0),
+        codeimageEnd(0)
   {
     ArgParser parser;
     Arg classpath(parser, true, "cp", "<classpath>");
     Arg bootimage(parser, true, "bootimage", "<bootimage file>");
     Arg codeimage(parser, true, "codeimage", "<codeimage file>");
-    Arg entry(parser, false, "entry", "<class name>[.<method name>[<method spec>]]");
-    Arg bootimageSymbols(parser, false, "bootimage-symbols", "<start symbol name>:<end symbol name>");
-    Arg codeimageSymbols(parser, false, "codeimage-symbols", "<start symbol name>:<end symbol name>");
+    Arg entry(
+        parser, false, "entry", "<class name>[.<method name>[<method spec>]]");
+    Arg bootimageSymbols(parser,
+                         false,
+                         "bootimage-symbols",
+                         "<start symbol name>:<end symbol name>");
+    Arg codeimageSymbols(parser,
+                         false,
+                         "codeimage-symbols",
+                         "<start symbol name>:<end symbol name>");
     Arg useLZMA(parser, false, "use-lzma", 0);
 
-    if(!parser.parse(ac, av)) {
+    if (!parser.parse(ac, av)) {
       parser.printUsage(av[0]);
       exit(1);
     }
@@ -1895,11 +2019,12 @@ public:
     this->codeimage = codeimage.value;
     this->useLZMA = useLZMA.value != 0;
 
-    if(entry.value) {
-      if(const char* entryClassEnd = strchr(entry.value, '.')) {
+    if (entry.value) {
+      if (const char* entryClassEnd = strchr(entry.value, '.')) {
         entryClass = myStrndup(entry.value, entryClassEnd - entry.value);
-        if(const char* entryMethodEnd = strchr(entryClassEnd, '(')) {
-          entryMethod = myStrndup(entryClassEnd + 1, entryMethodEnd - entryClassEnd - 1);
+        if (const char* entryMethodEnd = strchr(entryClassEnd, '(')) {
+          entryMethod = myStrndup(entryClassEnd + 1,
+                                  entryMethodEnd - entryClassEnd - 1);
           entrySpec = strdup(entryMethodEnd);
         } else {
           entryMethod = strdup(entryClassEnd + 1);
@@ -1909,85 +2034,84 @@ public:
       }
     }
 
-    if(!maybeSplit(bootimageSymbols.value, bootimageStart, bootimageEnd) ||
-       !maybeSplit(codeimageSymbols.value, codeimageStart, codeimageEnd))
-    {
+    if (!maybeSplit(bootimageSymbols.value, bootimageStart, bootimageEnd)
+        || !maybeSplit(codeimageSymbols.value, codeimageStart, codeimageEnd)) {
       fprintf(stderr, "wrong format for symbols\n");
       parser.printUsage(av[0]);
       exit(1);
     }
 
-    if(!bootimageStart) {
+    if (!bootimageStart) {
       bootimageStart = strdup("_binary_bootimage_bin_start");
     }
 
-    if(!bootimageEnd) {
+    if (!bootimageEnd) {
       bootimageEnd = strdup("_binary_bootimage_bin_end");
     }
 
-    if(!codeimageStart) {
+    if (!codeimageStart) {
       codeimageStart = strdup("_binary_codeimage_bin_start");
     }
 
-    if(!codeimageEnd) {
+    if (!codeimageEnd) {
       codeimageEnd = strdup("_binary_codeimage_bin_end");
     }
-
   }
 
-  ~Arguments() {
-    if(entryClass) {
+  ~Arguments()
+  {
+    if (entryClass) {
       free(entryClass);
     }
-    if(entryMethod) {
+    if (entryMethod) {
       free(entryMethod);
     }
-    if(entrySpec) {
+    if (entrySpec) {
       free(entrySpec);
     }
-    if(bootimageStart) {
+    if (bootimageStart) {
       free(bootimageStart);
     }
-    if(bootimageEnd) {
+    if (bootimageEnd) {
       free(bootimageEnd);
     }
-    if(codeimageStart) {
+    if (codeimageStart) {
       free(codeimageStart);
     }
-    if(codeimageEnd) {
+    if (codeimageEnd) {
       free(codeimageEnd);
     }
   }
 
-  void dump() {
+  void dump()
+  {
     printf(
-      "classpath = %s\n"
-      "bootimage = %s\n"
-      "codeimage = %s\n"
-      "entryClass = %s\n"
-      "entryMethod = %s\n"
-      "entrySpec = %s\n"
-      "bootimageStart = %s\n"
-      "bootimageEnd = %s\n"
-      "codeimageStart = %s\n"
-      "codeimageEnd = %s\n",
-      classpath,
-      bootimage,
-      codeimage,
-      entryClass,
-      entryMethod,
-      entrySpec,
-      bootimageStart,
-      bootimageEnd,
-      codeimageStart,
-      codeimageEnd);
+        "classpath = %s\n"
+        "bootimage = %s\n"
+        "codeimage = %s\n"
+        "entryClass = %s\n"
+        "entryMethod = %s\n"
+        "entrySpec = %s\n"
+        "bootimageStart = %s\n"
+        "bootimageEnd = %s\n"
+        "codeimageStart = %s\n"
+        "codeimageEnd = %s\n",
+        classpath,
+        bootimage,
+        codeimage,
+        entryClass,
+        entryMethod,
+        entrySpec,
+        bootimageStart,
+        bootimageEnd,
+        codeimageStart,
+        codeimageEnd);
   }
 };
 
-} // namespace
+}  // namespace
 
-int
-main(int ac, const char** av)
+int main(int ac, const char** av)
 {
   Arguments args(ac, av);
   // args.dump();
@@ -1998,13 +2122,13 @@ main(int ac, const char** av)
   Finder* f = makeFinder(s, h, args.classpath, 0);
   Processor* p = makeProcessor(s, h, 0, false);
 
-  // todo: currently, the compiler cannot compile code with jumps or
-  // calls spanning more than the maximum size of an immediate value
-  // in a branch instruction for the target architecture (~32MB on ARM).
-  // When that limitation is removed, we'll be able to specify a
-  // capacity as large as we like here:
+// todo: currently, the compiler cannot compile code with jumps or
+// calls spanning more than the maximum size of an immediate value
+// in a branch instruction for the target architecture (~32MB on ARM).
+// When that limitation is removed, we'll be able to specify a
+// capacity as large as we like here:
 #if (AVIAN_TARGET_ARCH == AVIAN_ARCH_X86_64) \
-  || (AVIAN_TARGET_ARCH == AVIAN_ARCH_X86)
+    || (AVIAN_TARGET_ARCH == AVIAN_ARCH_X86)
   const unsigned CodeCapacity = 128 * 1024 * 1024;
 #else
   const unsigned CodeCapacity = 30 * 1024 * 1024;
@@ -2014,8 +2138,8 @@ main(int ac, const char** av)
   BootImage image;
   p->initialize(&image, code);
 
-  Machine* m = new (h->allocate(sizeof(Machine))) Machine
-    (s, h, f, 0, p, c, 0, 0, 0, 0, 128 * 1024);
+  Machine* m = new (h->allocate(sizeof(Machine)))
+      Machine(s, h, f, 0, p, c, 0, 0, 0, 0, 128 * 1024);
   Thread* t = p->makeThread(m, 0, 0);
 
   enter(t, Thread::ActiveState);
diff --git a/src/tools/object-writer/elf.cpp b/src/tools/object-writer/elf.cpp
index 6f39d48fc9..2733ee0225 100644
--- a/src/tools/object-writer/elf.cpp
+++ b/src/tools/object-writer/elf.cpp
@@ -64,7 +64,7 @@
 
 #define STV_DEFAULT 0
 
-#define SYMBOL_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
+#define SYMBOL_INFO(bind, type) (((bind) << 4) + ((type)&0xf))
 
 #define OSABI ELFOSABI_SYSV
 
@@ -73,7 +73,7 @@ namespace {
 using namespace avian::tools;
 using namespace avian::util;
 
-template<class AddrTy>
+template <class AddrTy>
 struct ElfTypes {
   typedef uint16_t Half;
   typedef uint32_t Word;
@@ -85,10 +85,10 @@ struct ElfTypes {
   static const unsigned BytesPerWord = sizeof(AddrTy);
 };
 
-template<class AddrTy>
+template <class AddrTy>
 struct Symbol_Ty;
 
-template<>
+template <>
 struct Symbol_Ty<uint64_t> {
   typedef ElfTypes<uint64_t> Elf;
 
@@ -100,7 +100,7 @@ struct Symbol_Ty<uint64_t> {
   Elf::Xword st_size;
 };
 
-template<>
+template <>
 struct Symbol_Ty<uint32_t> {
   typedef ElfTypes<uint32_t> Elf;
 
@@ -120,9 +120,9 @@ using avian::endian::Endianness;
 #define V4 Endianness<TargetLittleEndian>::v4
 #define VANY Endianness<TargetLittleEndian>::vAny
 
-
-unsigned getElfPlatform(PlatformInfo::Architecture arch) {
-  switch(arch) {
+unsigned getElfPlatform(PlatformInfo::Architecture arch)
+{
+  switch (arch) {
   case PlatformInfo::x86_64:
     return EM_X86_64;
   case PlatformInfo::x86:
@@ -134,7 +134,8 @@ unsigned getElfPlatform(PlatformInfo::Architecture arch) {
   }
 }
 
-const char* getSectionName(unsigned accessFlags, unsigned& sectionFlags) {
+const char* getSectionName(unsigned accessFlags, unsigned& sectionFlags)
+{
   sectionFlags = SHF_ALLOC;
   if (accessFlags & Platform::Writable) {
     if (accessFlags & Platform::Executable) {
@@ -152,10 +153,9 @@ const char* getSectionName(unsigned accessFlags, unsigned& sectionFlags) {
   }
 }
 
-template<class AddrTy, bool TargetLittleEndian = true>
+template <class AddrTy, bool TargetLittleEndian = true>
 class ElfPlatform : public Platform {
-public:
-
+ public:
   typedef ElfTypes<AddrTy> Elf;
   static const unsigned Class = Elf::BytesPerWord / 4;
 
@@ -191,16 +191,19 @@ public:
 
   typedef Symbol_Ty<AddrTy> Symbol;
 
-  static const unsigned Encoding = TargetLittleEndian ? ELFDATA2LSB : ELFDATA2MSB;
+  static const unsigned Encoding = TargetLittleEndian ? ELFDATA2LSB
+                                                      : ELFDATA2MSB;
 
   const unsigned machine;
 
-  ElfPlatform(PlatformInfo::Architecture arch):
-    Platform(PlatformInfo(PlatformInfo::Elf, arch)),
-    machine(getElfPlatform(arch)) {}
+  ElfPlatform(PlatformInfo::Architecture arch)
+      : Platform(PlatformInfo(PlatformInfo::Elf, arch)),
+        machine(getElfPlatform(arch))
+  {
+  }
 
   class FileWriter {
-  public:
+   public:
     unsigned sectionCount;
     unsigned sectionStringTableSectionNumber;
 
@@ -209,9 +212,8 @@ public:
     FileHeader header;
     StringTable strings;
 
-    FileWriter(unsigned machine):
-      sectionCount(0),
-      dataOffset(sizeof(FileHeader))
+    FileWriter(unsigned machine)
+        : sectionCount(0), dataOffset(sizeof(FileHeader))
     {
       memset(&header, 0, sizeof(FileHeader));
       header.e_ident[EI_MAG0] = V1(ELFMAG0);
@@ -236,7 +238,8 @@ public:
       header.e_shentsize = V2(sizeof(SectionHeader));
     }
 
-    void writeHeader(OutputStream* out) {
+    void writeHeader(OutputStream* out)
+    {
       header.e_shnum = V2(sectionCount);
       header.e_shstrndx = V2(sectionStringTableSectionNumber);
       out->writeChunk(&header, sizeof(FileHeader));
@@ -244,18 +247,14 @@ public:
   };
 
   class SectionWriter {
-  public:
+   public:
     FileWriter& file;
     String name;
     SectionHeader header;
     const size_t* dataSize;
     const uint8_t* const* data;
 
-    SectionWriter(FileWriter& file):
-      file(file),
-      name(""),
-      dataSize(0),
-      data(0)
+    SectionWriter(FileWriter& file) : file(file), name(""), dataSize(0), data(0)
     {
       memset(&header, 0, sizeof(SectionHeader));
       file.sectionCount++;
@@ -264,24 +263,19 @@ public:
       header.sh_name = V4(nameOffset);
     }
 
-    SectionWriter(
-        FileWriter& file,
-        const char* chname,
-        unsigned type,
-        AddrTy flags,
-        unsigned alignment,
-        AddrTy addr,
-        const uint8_t* const* data,
-        size_t* dataSize,
-        size_t entsize = 0,
-        unsigned link = 0):
-
-      file(file),
-      name(chname),
-      dataSize(dataSize),
-      data(data)
+    SectionWriter(FileWriter& file,
+                  const char* chname,
+                  unsigned type,
+                  AddrTy flags,
+                  unsigned alignment,
+                  AddrTy addr,
+                  const uint8_t* const* data,
+                  size_t* dataSize,
+                  size_t entsize = 0,
+                  unsigned link = 0)
+        : file(file), name(chname), dataSize(dataSize), data(data)
     {
-      if(strcmp(chname, ".shstrtab") == 0) {
+      if (strcmp(chname, ".shstrtab") == 0) {
         file.sectionStringTableSectionNumber = file.sectionCount;
       }
       file.sectionCount++;
@@ -300,8 +294,9 @@ public:
       header.sh_entsize = VANY(static_cast<AddrTy>(entsize));
     }
 
-    void writeHeader(OutputStream* out) {
-      if(dataSize) {
+    void writeHeader(OutputStream* out)
+    {
+      if (dataSize) {
         header.sh_offset = VANY(file.dataOffset);
         header.sh_size = VANY(static_cast<AddrTy>(*dataSize));
         file.dataOffset += *dataSize;
@@ -310,17 +305,20 @@ public:
       out->writeChunk(&header, sizeof(SectionHeader));
     }
 
-    void writeData(OutputStream* out) {
-      if(data) {
+    void writeData(OutputStream* out)
+    {
+      if (data) {
         out->writeChunk(*data, *dataSize);
       }
     }
-
-
   };
 
-  virtual bool writeObject(OutputStream* out, Slice<SymbolInfo> symbols, Slice<const uint8_t> data, unsigned accessFlags, unsigned alignment) {
-
+  virtual bool writeObject(OutputStream* out,
+                           Slice<SymbolInfo> symbols,
+                           Slice<const uint8_t> data,
+                           unsigned accessFlags,
+                           unsigned alignment)
+  {
     unsigned sectionFlags;
     const char* sectionName = getSectionName(accessFlags, sectionFlags);
 
@@ -332,18 +330,46 @@ public:
     const int bodySectionNumber = 1;
     const int stringTableSectionNumber = 3;
 
-    SectionWriter sections[] = {
-      SectionWriter(file), // null section
-      SectionWriter(file, sectionName, SHT_PROGBITS, sectionFlags, alignment, 0, &data.items, &data.count), // body section
-      SectionWriter(file, ".shstrtab", SHT_STRTAB, 0, 1, 0, &file.strings.data, &file.strings.length),
-      SectionWriter(file, ".strtab", SHT_STRTAB, 0, 1, 0, &symbolStringTable.data, &symbolStringTable.length),
-      SectionWriter(file, ".symtab", SHT_SYMTAB, 0, 8, 0, &symbolTable.data, &symbolTable.length, sizeof(Symbol), stringTableSectionNumber)
-    };
+    SectionWriter sections[] = {SectionWriter(file),  // null section
+                                SectionWriter(file,
+                                              sectionName,
+                                              SHT_PROGBITS,
+                                              sectionFlags,
+                                              alignment,
+                                              0,
+                                              &data.items,
+                                              &data.count),  // body section
+                                SectionWriter(file,
+                                              ".shstrtab",
+                                              SHT_STRTAB,
+                                              0,
+                                              1,
+                                              0,
+                                              &file.strings.data,
+                                              &file.strings.length),
+                                SectionWriter(file,
+                                              ".strtab",
+                                              SHT_STRTAB,
+                                              0,
+                                              1,
+                                              0,
+                                              &symbolStringTable.data,
+                                              &symbolStringTable.length),
+                                SectionWriter(file,
+                                              ".symtab",
+                                              SHT_SYMTAB,
+                                              0,
+                                              8,
+                                              0,
+                                              &symbolTable.data,
+                                              &symbolTable.length,
+                                              sizeof(Symbol),
+                                              stringTableSectionNumber)};
 
     // for some reason, string tables require a null first element...
     symbolStringTable.add("");
 
-    for(SymbolInfo* sym = symbols.begin(); sym != symbols.end(); sym++) {
+    for (SymbolInfo* sym = symbols.begin(); sym != symbols.end(); sym++) {
       size_t nameOffset = symbolStringTable.add(sym->name);
 
       Symbol symbolStruct;
@@ -358,11 +384,11 @@ public:
 
     file.writeHeader(out);
 
-    for(unsigned i = 0; i < file.sectionCount; i++) {
+    for (unsigned i = 0; i < file.sectionCount; i++) {
       sections[i].writeHeader(out);
     }
 
-    for(unsigned i = 0; i < file.sectionCount; i++) {
+    for (unsigned i = 0; i < file.sectionCount; i++) {
       sections[i].writeData(out);
     }
 
@@ -374,4 +400,4 @@ ElfPlatform<uint32_t> elfX86Platform(PlatformInfo::x86);
 ElfPlatform<uint32_t> elfArmPlatform(PlatformInfo::Arm);
 ElfPlatform<uint64_t> elfX86_64Platform(PlatformInfo::x86_64);
 
-} // namespace
+}  // namespace
diff --git a/src/tools/object-writer/endianness.h b/src/tools/object-writer/endianness.h
index 182b249c52..0eef233d1a 100644
--- a/src/tools/object-writer/endianness.h
+++ b/src/tools/object-writer/endianness.h
@@ -22,60 +22,69 @@ static union {
 
 const bool LittleEndian = _DetectEndianness.c[0] == 1;
 
-template<bool TargetLittleEndian>
+template <bool TargetLittleEndian>
 class Endianness {
-public:
-  static inline uint8_t v1(uint8_t v) {
+ public:
+  static inline uint8_t v1(uint8_t v)
+  {
     return v;
   }
 
-  static inline uint16_t v2(uint16_t v) {
-    if(LittleEndian == TargetLittleEndian) {
+  static inline uint16_t v2(uint16_t v)
+  {
+    if (LittleEndian == TargetLittleEndian) {
       return v;
     } else {
       return ((v >> 8) & 0xFF) | (v << 8);
     }
   }
 
-  static inline uint32_t v4(uint32_t v) {
-    if(LittleEndian == TargetLittleEndian) {
+  static inline uint32_t v4(uint32_t v)
+  {
+    if (LittleEndian == TargetLittleEndian) {
       return v;
     } else {
-      return
-        ((v >> 24) & 0x000000FF) |
-         ((v >>  8) & 0x0000FF00) |
-         ((v <<  8) & 0x00FF0000) |
-         ((v << 24));
+      return ((v >> 24) & 0x000000FF) | ((v >> 8) & 0x0000FF00)
+             | ((v << 8) & 0x00FF0000) | ((v << 24));
     }
   }
 
-  static inline uint32_t vAny(uint32_t v) {
+  static inline uint32_t vAny(uint32_t v)
+  {
     return v4(v);
   }
 
-  static inline uint64_t v8(uint64_t v) {
-    if(LittleEndian == TargetLittleEndian) {
+  static inline uint64_t v8(uint64_t v)
+  {
+    if (LittleEndian == TargetLittleEndian) {
       return v;
     } else {
-      return
-        ((static_cast<uint64_t>(v) >> 56) & (static_cast<uint64_t>(0xff) << 0)) |
-        ((static_cast<uint64_t>(v) >> 40) & (static_cast<uint64_t>(0xff) << 8)) |
-        ((static_cast<uint64_t>(v) >> 24) & (static_cast<uint64_t>(0xff) << 16)) |
-        ((static_cast<uint64_t>(v) >>  8) & (static_cast<uint64_t>(0xff) << 24)) |
-        ((static_cast<uint64_t>(v) <<  8) & (static_cast<uint64_t>(0xff) << 32)) |
-        ((static_cast<uint64_t>(v) << 24) & (static_cast<uint64_t>(0xff) << 40)) |
-        ((static_cast<uint64_t>(v) << 40) & (static_cast<uint64_t>(0xff) << 48)) |
-        ((static_cast<uint64_t>(v) << 56));
+      return ((static_cast<uint64_t>(v) >> 56)
+              & (static_cast<uint64_t>(0xff) << 0))
+             | ((static_cast<uint64_t>(v) >> 40)
+                & (static_cast<uint64_t>(0xff) << 8))
+             | ((static_cast<uint64_t>(v) >> 24)
+                & (static_cast<uint64_t>(0xff) << 16))
+             | ((static_cast<uint64_t>(v) >> 8)
+                & (static_cast<uint64_t>(0xff) << 24))
+             | ((static_cast<uint64_t>(v) << 8)
+                & (static_cast<uint64_t>(0xff) << 32))
+             | ((static_cast<uint64_t>(v) << 24)
+                & (static_cast<uint64_t>(0xff) << 40))
+             | ((static_cast<uint64_t>(v) << 40)
+                & (static_cast<uint64_t>(0xff) << 48))
+             | ((static_cast<uint64_t>(v) << 56));
     }
   }
 
-  static inline uint64_t vAny(uint64_t v) {
+  static inline uint64_t vAny(uint64_t v)
+  {
     return v8(v);
   }
 };
 
-} // namespace endian
+}  // namespace endian
 
-} // namespace avian
+}  // namespace avian
 
-#endif // AVIAN_ENDIANNESS_H
+#endif  // AVIAN_ENDIANNESS_H
diff --git a/src/tools/object-writer/mach-o.cpp b/src/tools/object-writer/mach-o.cpp
index 89dec28e25..524407a381 100644
--- a/src/tools/object-writer/mach-o.cpp
+++ b/src/tools/object-writer/mach-o.cpp
@@ -55,18 +55,17 @@ using avian::endian::Endianness;
 #define V4 Endianness<TargetLittleEndian>::v4
 #define VANY Endianness<TargetLittleEndian>::vAny
 
-inline unsigned
-log(unsigned n)
+inline unsigned log(unsigned n)
 {
   unsigned r = 0;
-  for (unsigned i = 1; i < n; ++r) i <<= 1;
+  for (unsigned i = 1; i < n; ++r)
+    i <<= 1;
   return r;
 }
 
-template<class AddrTy, bool TargetLittleEndian = true>
+template <class AddrTy, bool TargetLittleEndian = true>
 class MachOPlatform : public Platform {
-public:
-
+ public:
   struct FileHeader {
     uint32_t magic;
     cpu_type_t cputype;
@@ -81,7 +80,6 @@ public:
     };
   };
 
-
   struct SegmentCommand {
     uint32_t cmd;
     uint32_t cmdsize;
@@ -112,7 +110,7 @@ public:
 
   struct NList {
     union {
-      uint32_t  n_strx;
+      uint32_t n_strx;
     } n_un;
     uint8_t n_type;
     uint8_t n_sect;
@@ -133,16 +131,20 @@ public:
   static const unsigned Segment = BytesPerWord == 8 ? 0x19 : 1;
   static const unsigned Magic = BytesPerWord == 8 ? 0xfeedfacf : 0xfeedface;
 
-  static inline unsigned
-  pad(unsigned n)
+  static inline unsigned pad(unsigned n)
   {
     return (n + (BytesPerWord - 1)) & ~(BytesPerWord - 1);
   }
 
-  virtual bool writeObject(OutputStream* out, Slice<SymbolInfo> symbols, Slice<const uint8_t> data, unsigned accessFlags, unsigned alignment) {
+  virtual bool writeObject(OutputStream* out,
+                           Slice<SymbolInfo> symbols,
+                           Slice<const uint8_t> data,
+                           unsigned accessFlags,
+                           unsigned alignment)
+  {
     cpu_type_t cpuType;
     cpu_subtype_t cpuSubType;
-    switch(info.arch) {
+    switch (info.arch) {
     case PlatformInfo::x86_64:
       cpuType = CPU_TYPE_X86_64;
       cpuSubType = CPU_SUBTYPE_X86_64_ALL;
@@ -177,53 +179,49 @@ public:
     }
 
     FileHeader header = {
-      V4(Magic), // magic
-      static_cast<cpu_type_t>(V4(cpuType)),
-      static_cast<cpu_subtype_t>(V4(cpuSubType)),
-      V4(MH_OBJECT), // filetype,
-      V4(2), // ncmds
-      V4(sizeof(SegmentCommand)
-         + sizeof(Section)
-         + sizeof(SymtabCommand)), // sizeofcmds
-      { V4(0) } // flags
+        V4(Magic),  // magic
+        static_cast<cpu_type_t>(V4(cpuType)),
+        static_cast<cpu_subtype_t>(V4(cpuSubType)),
+        V4(MH_OBJECT),  // filetype,
+        V4(2),          // ncmds
+        V4(sizeof(SegmentCommand) + sizeof(Section)
+           + sizeof(SymtabCommand)),  // sizeofcmds
+        {V4(0)}                       // flags
     };
 
     AddrTy finalSize = pad(data.count);
 
     SegmentCommand segment = {
-      V4(Segment), // cmd
-      V4(sizeof(SegmentCommand) + sizeof(Section)), // cmdsize
-      "", // segname
-      VANY(static_cast<AddrTy>(0)), // vmaddr
-      VANY(static_cast<AddrTy>(finalSize)), // vmsize
-      VANY(static_cast<AddrTy>(sizeof(FileHeader)
-         + sizeof(SegmentCommand)
-         + sizeof(Section)
-         + sizeof(SymtabCommand))), // fileoff
-      VANY(static_cast<AddrTy>(finalSize)), // filesize
-      static_cast<vm_prot_t>(V4(7)), // maxprot
-      static_cast<vm_prot_t>(V4(7)), // initprot
-      V4(1), // nsects
-      V4(0) // flags
+        V4(Segment),                                   // cmd
+        V4(sizeof(SegmentCommand) + sizeof(Section)),  // cmdsize
+        "",                                            // segname
+        VANY(static_cast<AddrTy>(0)),                  // vmaddr
+        VANY(static_cast<AddrTy>(finalSize)),          // vmsize
+        VANY(static_cast<AddrTy>(sizeof(FileHeader) + sizeof(SegmentCommand)
+                                 + sizeof(Section)
+                                 + sizeof(SymtabCommand))),  // fileoff
+        VANY(static_cast<AddrTy>(finalSize)),                // filesize
+        static_cast<vm_prot_t>(V4(7)),                       // maxprot
+        static_cast<vm_prot_t>(V4(7)),                       // initprot
+        V4(1),                                               // nsects
+        V4(0)                                                // flags
     };
 
     strncpy(segment.segname, segmentName, sizeof(segment.segname));
 
     Section sect = {
-      "", // sectname
-      "", // segname
-      VANY(static_cast<AddrTy>(0)), // addr
-      VANY(static_cast<AddrTy>(finalSize)), // size
-      V4(sizeof(FileHeader)
-         + sizeof(SegmentCommand)
-         + sizeof(Section)
-         + sizeof(SymtabCommand)), // offset
-      V4(log(alignment)), // align
-      V4(0), // reloff
-      V4(0), // nreloc
-      V4(S_REGULAR), // flags
-      V4(0), // reserved1
-      V4(0), // reserved2
+        "",                                    // sectname
+        "",                                    // segname
+        VANY(static_cast<AddrTy>(0)),          // addr
+        VANY(static_cast<AddrTy>(finalSize)),  // size
+        V4(sizeof(FileHeader) + sizeof(SegmentCommand) + sizeof(Section)
+           + sizeof(SymtabCommand)),  // offset
+        V4(log(alignment)),           // align
+        V4(0),                        // reloff
+        V4(0),                        // nreloc
+        V4(S_REGULAR),                // flags
+        V4(0),                        // reserved1
+        V4(0),                        // reserved2
     };
 
     strncpy(sect.segname, segmentName, sizeof(sect.segname));
@@ -233,36 +231,30 @@ public:
     strings.add("");
     Buffer symbolList;
 
-    for(SymbolInfo* sym = symbols.begin(); sym != symbols.end(); sym++) {
+    for (SymbolInfo* sym = symbols.begin(); sym != symbols.end(); sym++) {
       unsigned offset = strings.length;
       strings.write("_", 1);
       strings.add(sym->name);
       NList symbol = {
-        { V4(offset) }, // n_un
-        V1(N_SECT | N_EXT), // n_type
-        V1(1), // n_sect
-        V2(0), // n_desc
-        VANY(static_cast<AddrTy>(sym->addr)) // n_value
+          {V4(offset)},                         // n_un
+          V1(N_SECT | N_EXT),                   // n_type
+          V1(1),                                // n_sect
+          V2(0),                                // n_desc
+          VANY(static_cast<AddrTy>(sym->addr))  // n_value
       };
       symbolList.write(&symbol, sizeof(NList));
     }
 
     SymtabCommand symbolTable = {
-      V4(LC_SYMTAB), // cmd
-      V4(sizeof(SymtabCommand)), // cmdsize
-      V4(sizeof(FileHeader)
-         + sizeof(SegmentCommand)
-         + sizeof(Section)
-         + sizeof(SymtabCommand)
-         + finalSize), // symoff
-      V4(symbols.count), // nsyms
-      V4(sizeof(FileHeader)
-         + sizeof(SegmentCommand)
-         + sizeof(Section)
-         + sizeof(SymtabCommand)
-         + finalSize
-         + (sizeof(NList) * symbols.count)), // stroff
-      V4(strings.length), // strsize
+        V4(LC_SYMTAB),              // cmd
+        V4(sizeof(SymtabCommand)),  // cmdsize
+        V4(sizeof(FileHeader) + sizeof(SegmentCommand) + sizeof(Section)
+           + sizeof(SymtabCommand) + finalSize),  // symoff
+        V4(symbols.count),                        // nsyms
+        V4(sizeof(FileHeader) + sizeof(SegmentCommand) + sizeof(Section)
+           + sizeof(SymtabCommand) + finalSize
+           + (sizeof(NList) * symbols.count)),  // stroff
+        V4(strings.length),                     // strsize
     };
 
     out->writeChunk(&header, sizeof(header));
@@ -279,14 +271,15 @@ public:
 
     return true;
   }
-    
-  MachOPlatform(PlatformInfo::Architecture arch):
-    Platform(PlatformInfo(PlatformInfo::MachO, arch)) {}
-    
+
+  MachOPlatform(PlatformInfo::Architecture arch)
+      : Platform(PlatformInfo(PlatformInfo::MachO, arch))
+  {
+  }
 };
 
 MachOPlatform<uint32_t> darwinx86Platform(PlatformInfo::x86);
 MachOPlatform<uint32_t> darwinArmPlatform(PlatformInfo::Arm);
 MachOPlatform<uint64_t> darwinx86_64Platform(PlatformInfo::x86_64);
 
-} // namespace
+}  // namespace
diff --git a/src/tools/object-writer/pe.cpp b/src/tools/object-writer/pe.cpp
index 4b644950b8..dd3e976041 100644
--- a/src/tools/object-writer/pe.cpp
+++ b/src/tools/object-writer/pe.cpp
@@ -18,16 +18,18 @@
 namespace {
 
 // --- winnt.h ----
-#define IMAGE_SIZEOF_SHORT_NAME              8
+#define IMAGE_SIZEOF_SHORT_NAME 8
 
-#define IMAGE_FILE_RELOCS_STRIPPED           0x0001  // Relocation info stripped from file.
-#define IMAGE_FILE_LINE_NUMS_STRIPPED        0x0004  // Line nunbers stripped from file.
-#define IMAGE_FILE_MACHINE_AMD64             0x8664  // AMD64 (K8)
-#define IMAGE_FILE_MACHINE_I386              0x014c  // Intel 386.
-#define IMAGE_FILE_MACHINE_ARM               0x01c0  // ARM Little-Endian
-#define IMAGE_FILE_MACHINE_THUMB             0x01c2  // ARM Thumb/Thumb-2 Little-Endian
-#define IMAGE_FILE_MACHINE_ARMNT             0x01c4  // ARM Thumb-2 Little-Endian
-#define IMAGE_FILE_32BIT_MACHINE             0x0100  // 32 bit word machine.
+#define IMAGE_FILE_RELOCS_STRIPPED \
+  0x0001  // Relocation info stripped from file.
+#define IMAGE_FILE_LINE_NUMS_STRIPPED \
+  0x0004                                 // Line nunbers stripped from file.
+#define IMAGE_FILE_MACHINE_AMD64 0x8664  // AMD64 (K8)
+#define IMAGE_FILE_MACHINE_I386 0x014c   // Intel 386.
+#define IMAGE_FILE_MACHINE_ARM 0x01c0    // ARM Little-Endian
+#define IMAGE_FILE_MACHINE_THUMB 0x01c2  // ARM Thumb/Thumb-2 Little-Endian
+#define IMAGE_FILE_MACHINE_ARMNT 0x01c4  // ARM Thumb-2 Little-Endian
+#define IMAGE_FILE_32BIT_MACHINE 0x0100  // 32 bit word machine.
 
 #define IMAGE_SCN_ALIGN_1BYTES 0x100000
 #define IMAGE_SCN_ALIGN_2BYTES 0x200000
@@ -79,8 +81,7 @@ struct IMAGE_SYMBOL {
 } __attribute__((packed));
 // --- winnt.h ----
 
-inline unsigned
-pad(unsigned n)
+inline unsigned pad(unsigned n)
 {
   return (n + (4 - 1)) & ~(4 - 1);
 }
@@ -88,13 +89,11 @@ pad(unsigned n)
 using namespace avian::tools;
 using namespace avian::util;
 
-template<unsigned BytesPerWord, PlatformInfo::Architecture Architecture>
+template <unsigned BytesPerWord, PlatformInfo::Architecture Architecture>
 class WindowsPlatform : public Platform {
-public:
-
-
+ public:
   class FileWriter {
-  public:
+   public:
     unsigned sectionCount;
     unsigned symbolCount;
     unsigned dataStart;
@@ -105,11 +104,11 @@ public:
     StringTable strings;
     Buffer symbols;
 
-    FileWriter(unsigned machine, unsigned machineMask, unsigned symbolCount):
-      sectionCount(0),
-      symbolCount(symbolCount),
-      dataStart(sizeof(IMAGE_FILE_HEADER)),
-      dataOffset(0)
+    FileWriter(unsigned machine, unsigned machineMask, unsigned symbolCount)
+        : sectionCount(0),
+          symbolCount(symbolCount),
+          dataStart(sizeof(IMAGE_FILE_HEADER)),
+          dataOffset(0)
     {
       header.Machine = machine;
       // header.NumberOfSections = sectionCount;
@@ -120,11 +119,11 @@ public:
       // header.NumberOfSymbols = symbolCount;
       header.SizeOfOptionalHeader = 0;
       header.Characteristics = IMAGE_FILE_RELOCS_STRIPPED
-        | IMAGE_FILE_LINE_NUMS_STRIPPED
-        | machineMask;
+                               | IMAGE_FILE_LINE_NUMS_STRIPPED | machineMask;
     }
 
-    void writeHeader(OutputStream* out) {
+    void writeHeader(OutputStream* out)
+    {
       header.NumberOfSections = sectionCount;
       header.PointerToSymbolTable = dataStart + dataOffset;
       dataOffset = pad(dataOffset + symbolCount * sizeof(IMAGE_SYMBOL));
@@ -132,21 +131,27 @@ public:
       out->writeChunk(&header, sizeof(IMAGE_FILE_HEADER));
     }
 
-    void addSymbol(String name, unsigned addr, unsigned sectionNumber, unsigned type, unsigned storageClass) {
+    void addSymbol(String name,
+                   unsigned addr,
+                   unsigned sectionNumber,
+                   unsigned type,
+                   unsigned storageClass)
+    {
       unsigned nameOffset = strings.add(name);
       IMAGE_SYMBOL symbol = {
-        { { 0, 0 } }, // Name
-        addr, // Value
-        static_cast<int16_t>(sectionNumber), // SectionNumber
-        static_cast<uint16_t>(type), // Type
-        static_cast<uint8_t>(storageClass), // StorageClass
-        0, // NumberOfAuxSymbols
+          {{0, 0}},                             // Name
+          addr,                                 // Value
+          static_cast<int16_t>(sectionNumber),  // SectionNumber
+          static_cast<uint16_t>(type),          // Type
+          static_cast<uint8_t>(storageClass),   // StorageClass
+          0,                                    // NumberOfAuxSymbols
       };
-      symbol.N.Name.Long = nameOffset+4;
+      symbol.N.Name.Long = nameOffset + 4;
       symbols.write(&symbol, sizeof(IMAGE_SYMBOL));
     }
 
-    void writeData(OutputStream* out) {
+    void writeData(OutputStream* out)
+    {
       out->writeChunk(symbols.data, symbols.length);
       uint32_t size = strings.length + 4;
       out->writeChunk(&size, 4);
@@ -155,7 +160,7 @@ public:
   };
 
   class SectionWriter {
-  public:
+   public:
     FileWriter& file;
     IMAGE_SECTION_HEADER header;
     size_t dataSize;
@@ -163,17 +168,12 @@ public:
     const uint8_t* data;
     unsigned dataOffset;
 
-    SectionWriter(
-        FileWriter& file,
-        const char* name,
-        unsigned sectionMask,
-        const uint8_t* data,
-        size_t dataSize):
-
-      file(file),
-      dataSize(dataSize),
-      finalSize(pad(dataSize)),
-      data(data)
+    SectionWriter(FileWriter& file,
+                  const char* name,
+                  unsigned sectionMask,
+                  const uint8_t* data,
+                  size_t dataSize)
+        : file(file), dataSize(dataSize), finalSize(pad(dataSize)), data(data)
     {
       file.sectionCount++;
       file.dataStart += sizeof(IMAGE_SECTION_HEADER);
@@ -190,21 +190,25 @@ public:
       header.Characteristics = sectionMask;
     }
 
-    void writeHeader(OutputStream* out) {
+    void writeHeader(OutputStream* out)
+    {
       header.PointerToRawData = dataOffset + file.dataStart;
       out->writeChunk(&header, sizeof(IMAGE_SECTION_HEADER));
     }
 
-    void writeData(OutputStream* out) {
+    void writeData(OutputStream* out)
+    {
       out->writeChunk(data, dataSize);
       out->writeRepeat(0, finalSize - dataSize);
     }
-
-
   };
 
-  virtual bool writeObject(OutputStream* out, Slice<SymbolInfo> symbols, Slice<const uint8_t> data, unsigned accessFlags, unsigned alignment) {
-
+  virtual bool writeObject(OutputStream* out,
+                           Slice<SymbolInfo> symbols,
+                           Slice<const uint8_t> data,
+                           unsigned accessFlags,
+                           unsigned alignment)
+  {
     int machine;
     int machineMask;
 
@@ -245,9 +249,8 @@ public:
     if (accessFlags & Platform::Writable) {
       if (accessFlags & Platform::Executable) {
         sectionName = ".rwx";
-        sectionMask |= IMAGE_SCN_MEM_WRITE
-          | IMAGE_SCN_MEM_EXECUTE
-          | IMAGE_SCN_CNT_CODE;
+        sectionMask |= IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_EXECUTE
+                       | IMAGE_SCN_CNT_CODE;
       } else {
         sectionName = ".data";
         sectionMask |= IMAGE_SCN_MEM_WRITE;
@@ -259,11 +262,12 @@ public:
 
     FileWriter file(machine, machineMask, symbols.count);
 
-    SectionWriter section(file, sectionName, sectionMask, data.items, data.count);
+    SectionWriter section(
+        file, sectionName, sectionMask, data.items, data.count);
 
     file.writeHeader(out);
 
-    for(SymbolInfo* sym = symbols.begin(); sym != symbols.end(); sym++) {
+    for (SymbolInfo* sym = symbols.begin(); sym != symbols.end(); sym++) {
       file.addSymbol(sym->name, sym->addr, 1, 0, 2);
     }
 
@@ -271,18 +275,19 @@ public:
 
     section.writeData(out);
 
-    file.writeData(out);  
+    file.writeData(out);
 
     return true;
-
   }
 
-  WindowsPlatform():
-    Platform(PlatformInfo(PlatformInfo::Pe, Architecture)) {}
+  WindowsPlatform() : Platform(PlatformInfo(PlatformInfo::Pe, Architecture))
+  {
+  }
 };
 
 WindowsPlatform<4, PlatformInfo::x86> windows32Platform;
 WindowsPlatform<8, PlatformInfo::x86_64> windows64Platform;
-WindowsPlatform<4, PlatformInfo::Arm> windowsRtPlatform; // Windows Phone 8 and Windows RT
+WindowsPlatform<4, PlatformInfo::Arm>
+    windowsRtPlatform;  // Windows Phone 8 and Windows RT
 
-} // namespace
+}  // namespace
diff --git a/src/tools/object-writer/tools.cpp b/src/tools/object-writer/tools.cpp
index 1f4af566d1..5bd3739825 100644
--- a/src/tools/object-writer/tools.cpp
+++ b/src/tools/object-writer/tools.cpp
@@ -21,112 +21,115 @@ namespace avian {
 
 namespace tools {
 
-Buffer::Buffer():
-  capacity(100),
-  length(0),
-  data((uint8_t*)malloc(capacity)) {}
+Buffer::Buffer() : capacity(100), length(0), data((uint8_t*)malloc(capacity))
+{
+}
 
-Buffer::~Buffer() {
+Buffer::~Buffer()
+{
   free(data);
 }
 
-void Buffer::ensure(size_t more) {
-  if(length + more > capacity) {
+void Buffer::ensure(size_t more)
+{
+  if (length + more > capacity) {
     capacity = capacity * 2 + more;
     data = (uint8_t*)realloc(data, capacity);
   }
 }
 
-void Buffer::write(const void* d, size_t size) {
+void Buffer::write(const void* d, size_t size)
+{
   ensure(size);
   memcpy(data + length, d, size);
   length += size;
 }
 
-unsigned StringTable::add(String str) {
+unsigned StringTable::add(String str)
+{
   unsigned offset = Buffer::length;
   Buffer::write(str.text, str.length + 1);
   return offset;
 }
 
-void OutputStream::write(uint8_t byte) {
+void OutputStream::write(uint8_t byte)
+{
   writeChunk(&byte, 1);
 }
 
-void OutputStream::writeRepeat(uint8_t byte, size_t size) {
-  for(size_t i = 0; i < size; i++) {
+void OutputStream::writeRepeat(uint8_t byte, size_t size)
+{
+  for (size_t i = 0; i < size; i++) {
     write(byte);
   }
 }
 
-FileOutputStream::FileOutputStream(const char* name):
-  file(fopen(name, "wb")) {}
+FileOutputStream::FileOutputStream(const char* name) : file(fopen(name, "wb"))
+{
+}
 
-FileOutputStream::~FileOutputStream() {
-  if(file) {
+FileOutputStream::~FileOutputStream()
+{
+  if (file) {
     fclose(file);
   }
 }
 
-bool FileOutputStream::isValid() {
+bool FileOutputStream::isValid()
+{
   return file;
 }
 
-void FileOutputStream::writeChunk(const void* data, size_t size) {
+void FileOutputStream::writeChunk(const void* data, size_t size)
+{
   fwrite(data, size, 1, file);
 }
 
-void FileOutputStream::write(uint8_t byte) {
+void FileOutputStream::write(uint8_t byte)
+{
   fputc(byte, file);
 }
 
-
 Platform* Platform::first = 0;
 
-PlatformInfo::Format PlatformInfo::formatFromString(const char* format) {
-  if (strcmp(format, "elf") == 0
-      or strcmp(format, "linux") == 0
-      or strcmp(format, "freebsd") == 0
-      or strcmp(format, "qnx") == 0)
-  {
+PlatformInfo::Format PlatformInfo::formatFromString(const char* format)
+{
+  if (strcmp(format, "elf") == 0 or strcmp(format, "linux") == 0
+      or strcmp(format, "freebsd") == 0 or strcmp(format, "qnx") == 0) {
     return Elf;
-  } else if (strcmp(format, "pe") == 0
-             or strcmp(format, "windows") == 0)
-  {
+  } else if (strcmp(format, "pe") == 0 or strcmp(format, "windows") == 0) {
     return Pe;
-  } else if (strcmp(format, "macho") == 0
-             or strcmp(format, "darwin") == 0
-             or strcmp(format, "ios") == 0
-             or strcmp(format, "macosx") == 0)
-  {
+  } else if (strcmp(format, "macho") == 0 or strcmp(format, "darwin") == 0
+             or strcmp(format, "ios") == 0 or strcmp(format, "macosx") == 0) {
     return MachO;
   } else {
     return UnknownFormat;
   }
 }
 
-PlatformInfo::Architecture PlatformInfo::archFromString(const char* arch) {
-  if(strcmp(arch, "i386") == 0) {
+PlatformInfo::Architecture PlatformInfo::archFromString(const char* arch)
+{
+  if (strcmp(arch, "i386") == 0) {
     return x86;
-  } else if(strcmp(arch, "x86_64") == 0) {
+  } else if (strcmp(arch, "x86_64") == 0) {
     return x86_64;
-  } else if(strcmp(arch, "arm") == 0) {
+  } else if (strcmp(arch, "arm") == 0) {
     return Arm;
   } else {
     return UnknownArch;
   }
 }
 
-Platform* Platform::getPlatform(PlatformInfo info) {
-  for(Platform* p = first; p; p = p->next) {
-    if(p->info == info) {
+Platform* Platform::getPlatform(PlatformInfo info)
+{
+  for (Platform* p = first; p; p = p->next) {
+    if (p->info == info) {
       return p;
     }
   }
   return 0;
 }
 
-} // namespace tools
-
-} // namespace avian
+}  // namespace tools
 
+}  // namespace avian
diff --git a/src/tools/type-generator/io.h b/src/tools/type-generator/io.h
index b02a6e49e9..346ca5fa84 100644
--- a/src/tools/type-generator/io.h
+++ b/src/tools/type-generator/io.h
@@ -21,8 +21,10 @@ namespace typegenerator {
 
 class Input {
  public:
-  virtual ~Input() { }
-  
+  virtual ~Input()
+  {
+  }
+
   virtual void dispose() = 0;
 
   virtual int peek() = 0;
@@ -33,16 +35,20 @@ class Input {
 
   virtual unsigned column() = 0;
 
-  void skipSpace() {
+  void skipSpace()
+  {
     bool quit = false;
     while (not quit) {
       int c = peek();
       switch (c) {
-      case ' ': case '\t': case '\n':
+      case ' ':
+      case '\t':
+      case '\n':
         read();
         break;
 
-      default: quit = true;
+      default:
+        quit = true;
       }
     }
   }
@@ -56,56 +62,66 @@ class FileInput : public Input {
   unsigned column_;
   bool close;
 
-  FileInput(const char* file, FILE* stream = 0, bool close = true):
-    file(file), stream(stream), line_(1), column_(1), close(close)
-  { }
+  FileInput(const char* file, FILE* stream = 0, bool close = true)
+      : file(file), stream(stream), line_(1), column_(1), close(close)
+  {
+  }
 
-  virtual ~FileInput() {
+  virtual ~FileInput()
+  {
     dispose();
   }
 
-  virtual void dispose() {
+  virtual void dispose()
+  {
     if (stream and close) {
       fclose(stream);
       stream = 0;
     }
   }
 
-  virtual int peek() {
+  virtual int peek()
+  {
     int c = getc(stream);
     ungetc(c, stream);
     return c;
   }
 
-  virtual int read() {
+  virtual int read()
+  {
     int c = getc(stream);
     if (c == '\n') {
-      ++ line_;
+      ++line_;
       column_ = 1;
     } else {
-      ++ column_;
+      ++column_;
     }
     return c;
   }
 
-  virtual unsigned line() {
+  virtual unsigned line()
+  {
     return line_;
   }
 
-  virtual unsigned column() {
+  virtual unsigned column()
+  {
     return column_;
   }
 };
 
 class Output {
  public:
-  virtual ~Output() { }
-  
+  virtual ~Output()
+  {
+  }
+
   virtual void dispose() = 0;
 
   virtual void write(const std::string& s) = 0;
 
-  void write(int i) {
+  void write(int i)
+  {
     static const int Size = 32;
     char s[Size];
     int c UNUSED = ::snprintf(s, Size, "%d", i);
@@ -120,15 +136,18 @@ class FileOutput : public Output {
   FILE* stream;
   bool close;
 
-  FileOutput(const char* file, FILE* stream = 0, bool close = true):
-    file(file), stream(stream), close(close)
-  { }
+  FileOutput(const char* file, FILE* stream = 0, bool close = true)
+      : file(file), stream(stream), close(close)
+  {
+  }
 
-  virtual ~FileOutput() {
+  virtual ~FileOutput()
+  {
     dispose();
   }
 
-  virtual void dispose() {
+  virtual void dispose()
+  {
     if (stream and close) {
       fclose(stream);
       stream = 0;
@@ -140,13 +159,14 @@ class FileOutput : public Output {
     fputs(s.c_str(), stream);
   }
 
-  const char* filename() {
+  const char* filename()
+  {
     return file;
   }
 };
 
-} // namespace typegenerator
-} // namespace tools
-} // namespace avian
+}  // namespace typegenerator
+}  // namespace tools
+}  // namespace avian
 
-#endif // AVIAN_TOOLS_TYPE_GENERATOR_IO_H
+#endif  // AVIAN_TOOLS_TYPE_GENERATOR_IO_H
diff --git a/src/tools/type-generator/main.cpp b/src/tools/type-generator/main.cpp
index c2009520fe..75b5e273fe 100644
--- a/src/tools/type-generator/main.cpp
+++ b/src/tools/type-generator/main.cpp
@@ -199,7 +199,6 @@ class Module {
     }
   }
 };
-
 }
 }
 }
@@ -251,7 +250,8 @@ class Character : public Object {
  public:
   char value;
 
-  static Character* make(char value) {
+  static Character* make(char value)
+  {
     Character* o = allocate<Character>();
     o->type = Object::Character;
     o->value = value;
@@ -259,8 +259,7 @@ class Character : public Object {
   }
 };
 
-char
-character(Object* o)
+char character(Object* o)
 {
   assert(o->type == Object::Character);
   return static_cast<Character*>(o)->value;
@@ -270,19 +269,22 @@ class String : public Object {
  public:
   const char* value;
 
-  static String* make(Object* s) {
+  static String* make(Object* s)
+  {
     assert(s);
 
     String* o = allocate<String>();
     o->type = Object::String;
 
     unsigned length = 0;
-    for (Object* p = s; p; p = cdr(p)) ++ length;
+    for (Object* p = s; p; p = cdr(p))
+      ++length;
 
     char* value = static_cast<char*>(malloc(length + 1));
     assert(value);
     unsigned i = 0;
-    for (Object* p = s; p; p = cdr(p)) value[i++] = character(car(p));
+    for (Object* p = s; p; p = cdr(p))
+      value[i++] = character(car(p));
     value[i] = 0;
 
     o->value = value;
@@ -290,8 +292,7 @@ class String : public Object {
   }
 };
 
-const char*
-string(Object* o)
+const char* string(Object* o)
 {
   assert(o->type == Object::String);
   return static_cast<String*>(o)->value;
@@ -299,7 +300,8 @@ string(Object* o)
 
 class Singleton : public Object {
  public:
-  static Singleton* make(Object::ObjectType type) {
+  static Singleton* make(Object::ObjectType type)
+  {
     Singleton* o = allocate<Singleton>();
     o->type = type;
     return o;
@@ -314,8 +316,7 @@ std::string capitalize(const std::string& s)
   return s;
 }
 
-Object*
-read(Input* in, Object* eos, int level)
+Object* read(Input* in, Object* eos, int level)
 {
   List s;
 
@@ -349,7 +350,10 @@ read(Input* in, Object* eos, int level)
       }
     } break;
 
-    case ' ': case '\t': case '\n': case '\r': {
+    case ' ':
+    case '\t':
+    case '\n':
+    case '\r': {
       if (s.first) {
         return String::make(s.first);
       }
@@ -573,8 +577,7 @@ void parseSubdeclaration(Module& module, ClassParser& clparser, Object* p)
   }
 }
 
-const char*
-append(const char* a, const char* b, const char* c, const char* d)
+const char* append(const char* a, const char* b, const char* c, const char* d)
 {
   unsigned al = strlen(a);
   unsigned bl = strlen(b);
@@ -588,14 +591,12 @@ append(const char* a, const char* b, const char* c, const char* d)
   return p;
 }
 
-const char*
-append(const char* a, const char* b)
+const char* append(const char* a, const char* b)
 {
   return append(a, b, "", "");
 }
 
-const char*
-fieldType(const char* spec)
+const char* fieldType(const char* spec)
 {
   switch (*spec) {
   case 'B':
@@ -614,7 +615,8 @@ fieldType(const char* spec)
   case '[':
     return "object";
 
-  default: abort();
+  default:
+    abort();
   }
 }
 
@@ -622,8 +624,8 @@ void parseJavaClass(Module& module, ClassParser& clparser, Stream* s)
 {
   uint32_t magic = s->read4();
   assert(magic == 0xCAFEBABE);
-  s->read2(); // minor version
-  s->read2(); // major version
+  s->read2();  // minor version
+  s->read2();  // major version
 
   unsigned poolCount = s->read2() - 1;
   uintptr_t pool[poolCount];
@@ -665,25 +667,26 @@ void parseJavaClass(Module& module, ClassParser& clparser, Stream* s)
       pool[i] = s->read4();
       break;
 
-    default: abort();
+    default:
+      abort();
     }
   }
 
-  s->read2(); // flags
-  s->read2(); // name
+  s->read2();  // flags
+  s->read2();  // name
 
   unsigned superIndex = s->read2();
   if (superIndex) {
-    const char* name = reinterpret_cast<const char*>
-      (pool[pool[superIndex - 1] - 1]);
+    const char* name
+        = reinterpret_cast<const char*>(pool[pool[superIndex - 1] - 1]);
     Class* super = module.javaClasses[name];
     clparser.setSuper(super);
   }
 
   unsigned interfaceCount = s->read2();
   s->skip(interfaceCount * 2);
-//   for (unsigned i = 0; i < interfaceCount; ++i) {
-//     const char* name = reinterpret_cast<const char*>
+  //   for (unsigned i = 0; i < interfaceCount; ++i) {
+  //     const char* name = reinterpret_cast<const char*>
   //       (pool[pool[s->read2() - 1] - 1]);
   //   }
 
@@ -759,9 +762,10 @@ void parseType(Finder* finder, Module& module, Object* p)
   bool isJavaType = javaName and *javaName != '[';
 
   if (isJavaType) {
-    class Client: public Stream::Client {
+    class Client : public Stream::Client {
      public:
-      virtual void NO_RETURN handleError() {
+      virtual void NO_RETURN handleError()
+      {
         abort();
       }
     } client;
@@ -1339,8 +1343,7 @@ void writeEnums(Output* out, Module& module)
   }
 }
 
-void
-set(uint32_t* mask, unsigned index)
+void set(uint32_t* mask, unsigned index)
 {
   if (index < 32) {
     *mask |= 1 << index;
@@ -1566,18 +1569,16 @@ void writeMaps(Output* out, Module& module)
   out->write("\n};");
 }
 
-} // namespace local
+}  // namespace local
 
-} // namespace
+}  // namespace
 
-extern "C" uint64_t
-vmNativeCall(void*, void*, unsigned, unsigned)
+extern "C" uint64_t vmNativeCall(void*, void*, unsigned, unsigned)
 {
   abort();
 }
 
-extern "C" void
-vmJump(void*, void*, void*, void*, uintptr_t, uintptr_t)
+extern "C" void vmJump(void*, void*, void*, void*, uintptr_t, uintptr_t)
 {
   abort();
 }
diff --git a/src/tools/type-generator/sexpr.h b/src/tools/type-generator/sexpr.h
index dc208c94ec..40be9b2483 100644
--- a/src/tools/type-generator/sexpr.h
+++ b/src/tools/type-generator/sexpr.h
@@ -7,7 +7,7 @@
 
    There is NO WARRANTY for this software.  See license.txt for
    details. */
-   
+
 #ifndef AVIAN_TOOLS_TYPE_GENERATOR_SEXPR_H
 #define AVIAN_TOOLS_TYPE_GENERATOR_SEXPR_H
 
@@ -16,7 +16,8 @@ namespace tools {
 namespace typegenerator {
 
 template <class T>
-inline T* allocate() {
+inline T* allocate()
+{
   T* t = static_cast<T*>(malloc(sizeof(T)));
   assert(t);
   return t;
@@ -43,7 +44,8 @@ class Pair : public Object {
   Object* car;
   Object* cdr;
 
-  static Pair* make(Object* car, Object* cdr) {
+  static Pair* make(Object* car, Object* cdr)
+  {
     Pair* o = allocate<Pair>();
     o->type = Object::Pair;
     o->car = car;
@@ -52,26 +54,31 @@ class Pair : public Object {
   }
 };
 
-inline Object* cons(Object* car, Object* cdr) {
+inline Object* cons(Object* car, Object* cdr)
+{
   return Pair::make(car, cdr);
 }
 
-inline Object*& car(Object* o) {
+inline Object*& car(Object* o)
+{
   assert(o->type == Object::Pair);
   return static_cast<Pair*>(o)->car;
 }
 
-inline void setCar(Object* o, Object* v) {
+inline void setCar(Object* o, Object* v)
+{
   assert(o->type == Object::Pair);
   static_cast<Pair*>(o)->car = v;
 }
 
-inline Object*& cdr(Object* o) {
+inline Object*& cdr(Object* o)
+{
   assert(o->type == Object::Pair);
   return static_cast<Pair*>(o)->cdr;
 }
 
-inline void setCdr(Object* o, Object* v) {
+inline void setCdr(Object* o, Object* v)
+{
   assert(o->type == Object::Pair);
   static_cast<Pair*>(o)->cdr = v;
 }
@@ -81,9 +88,12 @@ class List {
   Object* first;
   Object* last;
 
-  List(): first(0), last(0) { }
+  List() : first(0), last(0)
+  {
+  }
 
-  void append(Object* o) {
+  void append(Object* o)
+  {
     Object* p = cons(o, 0);
     if (last) {
       setCdr(last, p);
@@ -94,8 +104,8 @@ class List {
   }
 };
 
-} // namespace typegenerator
-} // namespace tools
-} // namespace avian
+}  // namespace typegenerator
+}  // namespace tools
+}  // namespace avian
 
-#endif // AVIAN_TOOLS_TYPE_GENERATOR_SEXPR_H
+#endif  // AVIAN_TOOLS_TYPE_GENERATOR_SEXPR_H
diff --git a/src/util.cpp b/src/util.cpp
index 86d04ab0ef..bf7bd77d3d 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -17,14 +17,15 @@ namespace {
 
 class TreeContext {
  public:
-
-  class MyProtector: public Thread::Protector {
+  class MyProtector : public Thread::Protector {
    public:
-    MyProtector(Thread* thread, TreeContext* context):
-      Protector(thread), context(context)
-    { }
+    MyProtector(Thread* thread, TreeContext* context)
+        : Protector(thread), context(context)
+    {
+    }
 
-    virtual void visit(Heap::Visitor* v) {
+    virtual void visit(Heap::Visitor* v)
+    {
       v->visit(&(context->root));
       v->visit(&(context->node));
 
@@ -36,11 +37,16 @@ class TreeContext {
     TreeContext* context;
   };
 
-  TreeContext(Thread* thread, Zone* zone):
-    zone(zone), root(0), node(0), ancestors(0), protector(thread, this),
-    fresh(false)
-  { }
-  
+  TreeContext(Thread* thread, Zone* zone)
+      : zone(zone),
+        root(0),
+        node(0),
+        ancestors(0),
+        protector(thread, this),
+        fresh(false)
+  {
+  }
+
   Zone* zone;
   GcTreeNode* root;
   GcTreeNode* node;
@@ -58,8 +64,7 @@ List<GcTreeNode*>* path(TreeContext* c,
 
 inline object getTreeNodeValue(Thread*, GcTreeNode* n)
 {
-  return reinterpret_cast<object>
-    (alias(n, TreeNodeValue) & PointerMask);
+  return reinterpret_cast<object>(alias(n, TreeNodeValue) & PointerMask);
 }
 
 inline void setTreeNodeValue(Thread* t, GcTreeNode* n, object value)
@@ -158,7 +163,7 @@ void treeFind(Thread* t,
       return;
     }
 
-    if (++ count > 100) {
+    if (++count > 100) {
       // if we've gone this deep, we probably have an unbalanced tree,
       // which should only happen if there's a serious bug somewhere
       // in our insertion process
@@ -247,8 +252,8 @@ GcTreeNode* treeAdd(Thread* t, TreeContext* c)
         }
         // done
       }
-    } else { // this is just the reverse of the code above (right and
-             // left swapped):
+    } else {  // this is just the reverse of the code above (right and
+              // left swapped):
       if (treeNodeRed(t, c->ancestors->next->item->left())) {
         setTreeNodeRed(t, c->ancestors->item, false);
 
@@ -298,7 +303,7 @@ GcTreeNode* treeAdd(Thread* t, TreeContext* c)
   return newRoot;
 }
 
-} // namespace
+}  // namespace
 
 namespace vm {
 
@@ -596,4 +601,4 @@ void treeUpdate(Thread* t,
   setTreeNodeValue(t, treeFind(t, tree, key, sentinal, compare), value);
 }
 
-} // namespace vm
+}  // namespace vm
diff --git a/src/util/arg-parser.cpp b/src/util/arg-parser.cpp
index a6274e1186..80c5429ef3 100644
--- a/src/util/arg-parser.cpp
+++ b/src/util/arg-parser.cpp
@@ -17,40 +17,41 @@
 namespace avian {
 namespace util {
 
-Arg::Arg(ArgParser& parser, bool required, const char* name, const char* desc):
-  next(0),
-  required(required),
-  name(name),
-  desc(desc),
-  value(0)
+Arg::Arg(ArgParser& parser, bool required, const char* name, const char* desc)
+    : next(0), required(required), name(name), desc(desc), value(0)
 {
   *parser.last = this;
   parser.last = &next;
 }
 
-ArgParser::ArgParser():
-  first(0),
-  last(&first) {}
+ArgParser::ArgParser() : first(0), last(&first)
+{
+}
 
-bool ArgParser::parse(int ac, const char* const* av) {
+bool ArgParser::parse(int ac, const char* const* av)
+{
   Arg* state = 0;
 
-  for(int i = 1; i < ac; i++) {
-    if(state) {
-      if(state->value) {
-        fprintf(stderr, "duplicate parameter %s: '%s' and '%s'\n", state->name, state->value, av[i]);
+  for (int i = 1; i < ac; i++) {
+    if (state) {
+      if (state->value) {
+        fprintf(stderr,
+                "duplicate parameter %s: '%s' and '%s'\n",
+                state->name,
+                state->value,
+                av[i]);
         return false;
       }
       state->value = av[i];
       state = 0;
     } else {
-      if(av[i][0] != '-') {
+      if (av[i][0] != '-') {
         fprintf(stderr, "expected -parameter\n");
         return false;
       }
       bool found = false;
-      for(Arg* arg = first; arg; arg = arg->next) {
-        if(strcmp(arg->name, &av[i][1]) == 0) {
+      for (Arg* arg = first; arg; arg = arg->next) {
+        if (strcmp(arg->name, &av[i][1]) == 0) {
           found = true;
           if (arg->desc == 0) {
             arg->value = "true";
@@ -66,13 +67,13 @@ bool ArgParser::parse(int ac, const char* const* av) {
     }
   }
 
-  if(state) {
+  if (state) {
     fprintf(stderr, "expected argument after -%s\n", state->name);
     return false;
   }
 
-  for(Arg* arg = first; arg; arg = arg->next) {
-    if(arg->required && !arg->value) {
+  for (Arg* arg = first; arg; arg = arg->next) {
+    if (arg->required && !arg->value) {
       fprintf(stderr, "expected value for %s\n", arg->name);
       return false;
     }
@@ -81,11 +82,12 @@ bool ArgParser::parse(int ac, const char* const* av) {
   return true;
 }
 
-void ArgParser::printUsage(const char* exe) {
+void ArgParser::printUsage(const char* exe)
+{
   fprintf(stderr, "usage:\n%s \\\n", exe);
-  for(Arg* arg = first; arg; arg = arg->next) {
+  for (Arg* arg = first; arg; arg = arg->next) {
     const char* lineEnd = arg->next ? " \\" : "";
-    if(arg->required) {
+    if (arg->required) {
       fprintf(stderr, "  -%s\t%s%s\n", arg->name, arg->desc, lineEnd);
     } else if (arg->desc) {
       fprintf(stderr, "  [-%s\t%s]%s\n", arg->name, arg->desc, lineEnd);
@@ -95,5 +97,5 @@ void ArgParser::printUsage(const char* exe) {
   }
 }
 
-} // namespace util
-} // namespace avian
+}  // namespace util
+}  // namespace avian
diff --git a/src/util/fixed-allocator.cpp b/src/util/fixed-allocator.cpp
index ea8e237322..91d0d88621 100644
--- a/src/util/fixed-allocator.cpp
+++ b/src/util/fixed-allocator.cpp
@@ -42,8 +42,8 @@ void* FixedAllocator::allocate(unsigned size)
 
 void FixedAllocator::free(const void* p, unsigned size)
 {
-  if (p >= memory.begin() and static_cast<const uint8_t*>(p) + size
-      == memory.begin() + offset) {
+  if (p >= memory.begin()
+      and static_cast<const uint8_t*>(p) + size == memory.begin() + offset) {
     offset -= size;
   } else {
     abort(a);
diff --git a/test/jni.cpp b/test/jni.cpp
index 6bc11e12c2..70d5b63ed3 100644
--- a/test/jni.cpp
+++ b/test/jni.cpp
@@ -19,123 +19,175 @@ extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*)
   return JNI_VERSION_1_6;
 }
 
-extern "C" JNIEXPORT jdouble JNICALL
-Java_JNI_addDoubles
-(JNIEnv*, jclass,
- jdouble a1, jdouble a2, jdouble a3, jdouble a4, jdouble a5, jdouble a6,
- jdouble a7, jdouble a8, jdouble a9, jdouble a10, jdouble a11, jdouble a12,
- jdouble a13, jdouble a14, jdouble a15, jdouble a16, jdouble a17, jdouble a18,
- jdouble a19, jdouble a20)
+extern "C" JNIEXPORT jdouble JNICALL Java_JNI_addDoubles(JNIEnv*,
+                                                         jclass,
+                                                         jdouble a1,
+                                                         jdouble a2,
+                                                         jdouble a3,
+                                                         jdouble a4,
+                                                         jdouble a5,
+                                                         jdouble a6,
+                                                         jdouble a7,
+                                                         jdouble a8,
+                                                         jdouble a9,
+                                                         jdouble a10,
+                                                         jdouble a11,
+                                                         jdouble a12,
+                                                         jdouble a13,
+                                                         jdouble a14,
+                                                         jdouble a15,
+                                                         jdouble a16,
+                                                         jdouble a17,
+                                                         jdouble a18,
+                                                         jdouble a19,
+                                                         jdouble a20)
 {
   return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10 + a11 + a12 + a13
-    + a14 + a15 + a16 + a17 + a18 + a19 + a20;
+         + a14 + a15 + a16 + a17 + a18 + a19 + a20;
+}
+
+extern "C" JNIEXPORT jfloat JNICALL Java_JNI_addFloats(JNIEnv*,
+                                                       jclass,
+                                                       jfloat a1,
+                                                       jfloat a2,
+                                                       jfloat a3,
+                                                       jfloat a4,
+                                                       jfloat a5,
+                                                       jfloat a6,
+                                                       jfloat a7,
+                                                       jfloat a8,
+                                                       jfloat a9,
+                                                       jfloat a10,
+                                                       jfloat a11,
+                                                       jfloat a12,
+                                                       jfloat a13,
+                                                       jfloat a14,
+                                                       jfloat a15,
+                                                       jfloat a16,
+                                                       jfloat a17,
+                                                       jfloat a18,
+                                                       jfloat a19,
+                                                       jfloat a20)
+{
+  return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10 + a11 + a12 + a13
+         + a14 + a15 + a16 + a17 + a18 + a19 + a20;
+}
+
+extern "C" JNIEXPORT jdouble JNICALL Java_JNI_addMix(JNIEnv*,
+                                                     jclass,
+                                                     jfloat a1,
+                                                     jdouble a2,
+                                                     jfloat a3,
+                                                     jdouble a4,
+                                                     jfloat a5,
+                                                     jfloat a6,
+                                                     jfloat a7,
+                                                     jfloat a8,
+                                                     jfloat a9,
+                                                     jfloat a10,
+                                                     jfloat a11,
+                                                     jfloat a12,
+                                                     jfloat a13,
+                                                     jfloat a14,
+                                                     jfloat a15,
+                                                     jdouble a16,
+                                                     jfloat a17,
+                                                     jfloat a18,
+                                                     jfloat a19,
+                                                     jfloat a20)
+{
+  return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10 + a11 + a12 + a13
+         + a14 + a15 + a16 + a17 + a18 + a19 + a20;
 }
 
 extern "C" JNIEXPORT jfloat JNICALL
-Java_JNI_addFloats
-(JNIEnv*, jclass,
- jfloat a1, jfloat a2, jfloat a3, jfloat a4, jfloat a5, jfloat a6,
- jfloat a7, jfloat a8, jfloat a9, jfloat a10, jfloat a11, jfloat a12,
- jfloat a13, jfloat a14, jfloat a15, jfloat a16, jfloat a17, jfloat a18,
- jfloat a19, jfloat a20)
-{
-  return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10 + a11 + a12 + a13
-    + a14 + a15 + a16 + a17 + a18 + a19 + a20;
-}
-
-extern "C" JNIEXPORT jdouble JNICALL
-Java_JNI_addMix
-(JNIEnv*, jclass,
- jfloat a1, jdouble a2, jfloat a3, jdouble a4, jfloat a5, jfloat a6,
- jfloat a7, jfloat a8, jfloat a9, jfloat a10, jfloat a11, jfloat a12,
- jfloat a13, jfloat a14, jfloat a15, jdouble a16, jfloat a17, jfloat a18,
- jfloat a19, jfloat a20)
-{
-  return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10 + a11 + a12 + a13
-    + a14 + a15 + a16 + a17 + a18 + a19 + a20;
-}
-
-extern "C" JNIEXPORT jfloat JNICALL
-Java_JNI_doEcho__F(JNIEnv* e, jclass c, jfloat f)
+    Java_JNI_doEcho__F(JNIEnv* e, jclass c, jfloat f)
 {
   jvalue value;
   value.f = f;
-  jvalue array[] = { value };
-  return e->CallStaticFloatMethodA
-    (c, e->GetStaticMethodID(c, "echo", "(F)F"), array);
+  jvalue array[] = {value};
+  return e->CallStaticFloatMethodA(
+      c, e->GetStaticMethodID(c, "echo", "(F)F"), array);
 }
 
 extern "C" JNIEXPORT jdouble JNICALL
-Java_JNI_doEcho__D(JNIEnv* e, jclass c, jdouble f)
+    Java_JNI_doEcho__D(JNIEnv* e, jclass c, jdouble f)
 {
   jvalue value;
   value.d = f;
-  jvalue array[] = { value };
-  return e->CallStaticDoubleMethodA
-    (c, e->GetStaticMethodID(c, "echo", "(D)D"), array);
+  jvalue array[] = {value};
+  return e->CallStaticDoubleMethodA(
+      c, e->GetStaticMethodID(c, "echo", "(D)D"), array);
 }
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_JNI_fromReflectedMethod(JNIEnv* e, jclass, jobject method)
+    Java_JNI_fromReflectedMethod(JNIEnv* e, jclass, jobject method)
 {
   return reinterpret_cast<uintptr_t>(e->FromReflectedMethod(method));
 }
 
 extern "C" JNIEXPORT jobject JNICALL
-Java_JNI_toReflectedMethod(JNIEnv* e, jclass, jclass c, jlong id,
-                           jboolean isStatic)
+    Java_JNI_toReflectedMethod(JNIEnv* e,
+                               jclass,
+                               jclass c,
+                               jlong id,
+                               jboolean isStatic)
 {
   return e->ToReflectedMethod(c, reinterpret_cast<jmethodID>(id), isStatic);
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_JNI_callStaticIntMethod(JNIEnv* e, jclass, jclass c, jlong id)
+    Java_JNI_callStaticIntMethod(JNIEnv* e, jclass, jclass c, jlong id)
 {
   return e->CallStaticIntMethod(c, reinterpret_cast<jmethodID>(id));
 }
 
 extern "C" JNIEXPORT jobject JNICALL
-Java_JNI_newObject(JNIEnv* e, jclass, jclass c, jlong id)
+    Java_JNI_newObject(JNIEnv* e, jclass, jclass c, jlong id)
 {
   return e->NewObject(c, reinterpret_cast<jmethodID>(id));
 }
 
 extern "C" JNIEXPORT jlong JNICALL
-Java_JNI_fromReflectedField(JNIEnv* e, jclass, jobject field)
+    Java_JNI_fromReflectedField(JNIEnv* e, jclass, jobject field)
 {
   return reinterpret_cast<uintptr_t>(e->FromReflectedField(field));
 }
 
 extern "C" JNIEXPORT jobject JNICALL
-Java_JNI_toReflectedField(JNIEnv* e, jclass, jclass c, jlong id,
-                          jboolean isStatic)
+    Java_JNI_toReflectedField(JNIEnv* e,
+                              jclass,
+                              jclass c,
+                              jlong id,
+                              jboolean isStatic)
 {
   return e->ToReflectedField(c, reinterpret_cast<jfieldID>(id), isStatic);
 }
 
 extern "C" JNIEXPORT jint JNICALL
-Java_JNI_getStaticIntField(JNIEnv* e, jclass, jclass c, jlong id)
+    Java_JNI_getStaticIntField(JNIEnv* e, jclass, jclass c, jlong id)
 {
   return e->GetStaticIntField(c, reinterpret_cast<jfieldID>(id));
 }
 
 extern "C" JNIEXPORT jobject JNICALL
-Java_JNI_testLocalRef(JNIEnv* e, jclass, jobject o)
+    Java_JNI_testLocalRef(JNIEnv* e, jclass, jobject o)
 {
   return e->NewLocalRef(o);
 }
 
 extern "C" JNIEXPORT jobject JNICALL
-Java_Buffers_allocateNative(JNIEnv* e, jclass, jint capacity)
+    Java_Buffers_allocateNative(JNIEnv* e, jclass, jint capacity)
 {
   void* p = allocate(e, capacity);
-  if (p == 0) return 0;
+  if (p == 0)
+    return 0;
 
   return e->NewDirectByteBuffer(p, capacity);
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_Buffers_freeNative(JNIEnv* e, jclass, jobject b)
+    Java_Buffers_freeNative(JNIEnv* e, jclass, jobject b)
 {
   free(e->GetDirectBufferAddress(b));
 }
diff --git a/unittest/codegen/assembler-test.cpp b/unittest/codegen/assembler-test.cpp
index d115e81ee8..fa20b9a26c 100644
--- a/unittest/codegen/assembler-test.cpp
+++ b/unittest/codegen/assembler-test.cpp
@@ -22,61 +22,63 @@
 
 #include "test-harness.h"
 
-
 using namespace avian::codegen;
 using namespace vm;
 
 class BasicEnv {
-public:
+ public:
   System* s;
   Heap* heap;
   Architecture* arch;
 
-  BasicEnv():
-    s(makeSystem()),
-    heap(makeHeap(s, 32 * 1024)),
-    arch(makeArchitectureNative(s, true))
+  BasicEnv()
+      : s(makeSystem()),
+        heap(makeHeap(s, 32 * 1024)),
+        arch(makeArchitectureNative(s, true))
   {
     arch->acquire();
   }
 
-  ~BasicEnv() {
+  ~BasicEnv()
+  {
     arch->release();
     s->dispose();
   }
 };
 
 class Asm {
-public:
+ public:
   Zone zone;
   Assembler* a;
 
-  Asm(BasicEnv& env):
-    zone(env.s, env.heap, 8192),
-    a(env.arch->makeAssembler(env.heap, &zone))
-  { }
+  Asm(BasicEnv& env)
+      : zone(env.s, env.heap, 8192), a(env.arch->makeAssembler(env.heap, &zone))
+  {
+  }
 
-  ~Asm() {
+  ~Asm()
+  {
     a->dispose();
   }
 };
 
-
-TEST(BasicAssembler) {
+TEST(BasicAssembler)
+{
   BasicEnv env;
   Asm a(env);
 }
 
-TEST(ArchitecturePlan) {
+TEST(ArchitecturePlan)
+{
   BasicEnv env;
 
-  for(int op = (int)lir::Call; op < (int)lir::AlignedJump; op++) {
+  for (int op = (int)lir::Call; op < (int)lir::AlignedJump; op++) {
     bool thunk;
     OperandMask mask;
-    env.arch->plan((lir::UnaryOperation)op, vm::TargetBytesPerWord, mask, &thunk);
+    env.arch->plan(
+        (lir::UnaryOperation)op, vm::TargetBytesPerWord, mask, &thunk);
     assertFalse(thunk);
     assertNotEqual(static_cast<uint8_t>(0), mask.typeMask);
     assertNotEqual(static_cast<uint64_t>(0), mask.registerMask);
   }
-
 }
diff --git a/unittest/codegen/registers-test.cpp b/unittest/codegen/registers-test.cpp
index 215e9fa4cb..f565e813d7 100644
--- a/unittest/codegen/registers-test.cpp
+++ b/unittest/codegen/registers-test.cpp
@@ -14,12 +14,11 @@
 
 #include "test-harness.h"
 
-
 using namespace avian::codegen;
 using namespace vm;
 
-
-TEST(RegisterIterator) {
+TEST(RegisterIterator)
+{
   RegisterMask regs(0x55);
   assertEqual<unsigned>(0, regs.start);
   assertEqual<unsigned>(7, regs.limit);
diff --git a/unittest/test-harness.cpp b/unittest/test-harness.cpp
index 449ffc9ed0..13be65e104 100644
--- a/unittest/test-harness.cpp
+++ b/unittest/test-harness.cpp
@@ -14,28 +14,28 @@
 
 // since we aren't linking against libstdc++, we must implement this
 // ourselves:
-extern "C" void __cxa_pure_virtual(void) { abort(); }
+extern "C" void __cxa_pure_virtual(void)
+{
+  abort();
+}
 
 Test* Test::first = 0;
 Test** Test::last = &first;
 
-Test::Test(const char* name):
-  next(0),
-  failures(0),
-  runs(0),
-  name(name)
+Test::Test(const char* name) : next(0), failures(0), runs(0), name(name)
 {
   *last = this;
   last = &next;
 }
 
-bool Test::runAll() {
+bool Test::runAll()
+{
   int failures = 0;
-  for(Test* t = Test::first; t; t = t->next) {
+  for (Test* t = Test::first; t; t = t->next) {
     printf("%32s: ", t->name);
     t->run();
     failures += t->failures;
-    if(t->failures > 0) {
+    if (t->failures > 0) {
       printf("failure\n");
     } else {
       printf("success\n");
@@ -44,8 +44,9 @@ bool Test::runAll() {
   return failures == 0;
 }
 
-int main(int argc UNUSED, char** argv UNUSED) {
-  if(Test::runAll()) {
+int main(int argc UNUSED, char** argv UNUSED)
+{
+  if (Test::runAll()) {
     return 0;
   }
   return 1;
diff --git a/unittest/util/arg-parser-test.cpp b/unittest/util/arg-parser-test.cpp
index fec617ceee..f699845c7c 100644
--- a/unittest/util/arg-parser-test.cpp
+++ b/unittest/util/arg-parser-test.cpp
@@ -8,7 +8,6 @@
    There is NO WARRANTY for this software.  See license.txt for
    details. */
 
-
 #include <stdio.h>
 
 #include "avian/common.h"
@@ -19,17 +18,14 @@
 
 using namespace avian::util;
 
-TEST(ArgParser) {
+TEST(ArgParser)
+{
   {
     ArgParser parser;
     Arg arg1(parser, false, "arg1", "<value>");
     Arg required2(parser, true, "required2", "<value>");
-    const char* args[] = {
-      "myExecutable",
-      "-arg1", "myValue1",
-      "-required2", "myRequired2",
-      0
-    };
+    const char* args[]
+        = {"myExecutable", "-arg1", "myValue1", "-required2", "myRequired2", 0};
     assertTrue(parser.parse(sizeof(args) / sizeof(char*) - 1, args));
     assertEqual("myValue1", arg1.value);
     assertEqual("myRequired2", required2.value);
@@ -39,12 +35,7 @@ TEST(ArgParser) {
     ArgParser parser;
     Arg arg1(parser, false, "arg1", "<value>");
     Arg required2(parser, true, "required2", "<value>");
-    const char* args[] = {
-      "myExecutable",
-      "-arg1", "myValue1",
-      "-required2",
-      0
-    };
+    const char* args[] = {"myExecutable", "-arg1", "myValue1", "-required2", 0};
     assertFalse(parser.parse(sizeof(args) / sizeof(char*) - 1, args));
   }
 
@@ -52,11 +43,7 @@ TEST(ArgParser) {
     ArgParser parser;
     Arg arg1(parser, false, "arg1", "<value>");
     Arg required2(parser, true, "required2", "<value>");
-    const char* args[] = {
-      "myExecutable",
-      "-arg1", "myValue1",
-      0
-    };
+    const char* args[] = {"myExecutable", "-arg1", "myValue1", 0};
     assertFalse(parser.parse(sizeof(args) / sizeof(char*) - 1, args));
   }
 }